diff --git a/include/boost/test/utils/is_forward_iterable.hpp b/include/boost/test/utils/is_forward_iterable.hpp
index ed38b0dc30..202aed2b25 100755
--- a/include/boost/test/utils/is_forward_iterable.hpp
+++ b/include/boost/test/utils/is_forward_iterable.hpp
@@ -65,31 +65,60 @@ struct is_forward_iterable<std::list<T> > : public mpl::true_ {};
 
 namespace ut_detail {
 
-template<typename T>
-struct is_present : public mpl::true_ {};
-
-struct is_forward_iterable_impl {
-    template<typename T>
-    static typename std::enable_if<
-        is_present<typename T::const_iterator>::value            &&
-        is_present<typename T::value_type>::value                &&
-        is_present<decltype(boost::declval<T>().size())>::value  &&
-        is_present<decltype(boost::declval<T>().begin())>::value &&
-        !is_same<typename remove_cv<typename T::value_type>::type,char>::value &&
-        !is_same<typename remove_cv<typename T::value_type>::type,wchar_t>::value
-    , mpl::true_>::type
-    test(int);
-
-    template<typename> 
-    static std::false_type  test(...); 
-}; 
+  
+  template<typename T>
+  struct is_present : public mpl::true_ {};
+
+
+  // some compiler do not implement properly decltype non expression involving members (eg. VS2013)
+  // a workaround is to use -> decltype syntax.
+  template <class T>
+  struct has_member_size {
+  private:
+    struct nil_t;
+    template<typename T> static auto  test(T*) -> decltype( boost::declval<T>().size() );
+    template<typename>   static nil_t test(...);
+
+  public:
+    static bool const value = !std::is_same< decltype(test<T>(nullptr)), nil_t>::value;
+  };
+
+  template <class T>
+  struct has_member_begin {
+  private:
+    struct nil_t;
+    template<typename T>  static auto  test(T*) -> decltype( boost::declval<T>().begin() );
+    template<typename>    static nil_t test(...);
+  public:
+    static bool const value = !std::is_same< decltype(test<T>(nullptr)), nil_t>::value;
+  };
+
+
+  template <class T, class enabled = void>
+  struct is_forward_iterable_impl : std::false_type
+  {};
+
+  template <class T>
+  struct is_forward_iterable_impl<
+    T, 
+    typename std::enable_if<
+      is_present<typename T::const_iterator>::value &&
+      is_present<typename T::value_type>::value &&
+      has_member_size<T>::value &&
+      has_member_begin<T>::value &&
+      !is_same<typename remove_cv<typename T::value_type>::type,char>::value &&
+      !is_same<typename remove_cv<typename T::value_type>::type,wchar_t>::value
+      >::type 
+    > : std::true_type
+  {};
+
 
 } // namespace ut_detail
 
 template<typename T> 
-struct is_forward_iterable { 
-    typedef decltype(ut_detail::is_forward_iterable_impl::test<typename std::remove_reference<T>::type>(0)) type;
-    enum { value = type::value };
+struct is_forward_iterable  { 
+  typedef mpl::bool_<ut_detail::is_forward_iterable_impl<T>::value> type;
+  enum { value = ut_detail::is_forward_iterable_impl<T>::value };
 }; 
 
 #endif
diff --git a/test/test_assertion_construction.cpp b/test/test_assertion_construction.cpp
index 64ab707d2a..7d110d802f 100644
--- a/test/test_assertion_construction.cpp
+++ b/test/test_assertion_construction.cpp
@@ -14,7 +14,7 @@
 
 // Boost.Test
 #define BOOST_TEST_MODULE Boost.Test assertion consruction test
-#include <boost/test/unit_test.hpp>
+#include <boost/test/included/unit_test.hpp>
 #include <boost/test/tools/assertion.hpp>
 #ifdef BOOST_NO_CXX11_AUTO_DECLARATIONS
 #include <boost/test/tools/detail/expression_holder.hpp>
@@ -35,6 +35,102 @@
 #   define BOOST_TEST_FWD( a )  BOOST_TEST( a )
 #endif
 
+
+#ifndef BOOST_NO_CXX11_AUTO_DECLARATIONS
+
+// some broken compilers do not implement properly decltype on expressions
+struct not_fwd_iterable_1 {
+  typedef int const_iterator;
+  typedef int value_type;
+
+  bool size();
+};
+
+struct not_fwd_iterable_2 {
+  typedef int const_iterator;
+  typedef int value_type;
+
+  bool begin();
+};
+
+struct not_fwd_iterable_3 {
+  typedef int value_type;
+  bool begin();
+  bool size();
+};
+
+BOOST_AUTO_TEST_CASE( test_forward_iterable_concept )
+{
+  {
+    typedef std::vector<int> type;
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_size<type>::value, "has_member_size failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_begin<type>::value, "has_member_begin failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::is_forward_iterable< type >::value, "is_forward_iterable failed");
+  }
+
+  {
+    typedef std::list<int> type;
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_size<type>::value, "has_member_size failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_begin<type>::value, "has_member_begin failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::is_forward_iterable< type >::value, "is_forward_iterable failed");
+  }
+
+  {
+    typedef std::map<int, int> type;
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_size<type>::value, "has_member_size failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_begin<type>::value, "has_member_begin failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::is_forward_iterable< type >::value, "is_forward_iterable failed");
+  }
+
+  {
+    typedef std::set<int, int> type;
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_size<type>::value, "has_member_size failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_begin<type>::value, "has_member_begin failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::is_forward_iterable< type >::value, "is_forward_iterable failed");
+  }
+
+
+  {
+    typedef float type;
+    BOOST_CHECK_MESSAGE(!boost::unit_test::ut_detail::has_member_size<type>::value, "has_member_size failed");
+    BOOST_CHECK_MESSAGE(!boost::unit_test::ut_detail::has_member_begin<type>::value, "has_member_begin failed");
+    BOOST_CHECK_MESSAGE(!boost::unit_test::is_forward_iterable< type >::value, "is_forward_iterable failed");
+  }
+
+  {
+    typedef not_fwd_iterable_1 type;
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_size<type>::value, "has_member_size failed");
+    BOOST_CHECK_MESSAGE(!boost::unit_test::ut_detail::has_member_begin<type>::value, "has_member_begin failed");
+    BOOST_CHECK_MESSAGE(!boost::unit_test::is_forward_iterable< type >::value, "is_forward_iterable failed");
+  }
+
+  {
+    typedef not_fwd_iterable_2 type;
+    BOOST_CHECK_MESSAGE(!boost::unit_test::ut_detail::has_member_size<type>::value, "has_member_size failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_begin<type>::value, "has_member_begin failed");
+    BOOST_CHECK_MESSAGE(!boost::unit_test::is_forward_iterable< type >::value, "is_forward_iterable failed");
+  }
+
+  {
+    typedef not_fwd_iterable_3 type;
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_size<type>::value, "has_member_size failed");
+    BOOST_CHECK_MESSAGE(boost::unit_test::ut_detail::has_member_begin<type>::value, "has_member_begin failed");
+    BOOST_CHECK_MESSAGE(!boost::unit_test::is_forward_iterable< type >::value, "is_forward_iterable failed");
+  }
+
+  {
+    typedef char type;
+    BOOST_CHECK_MESSAGE(!boost::unit_test::ut_detail::has_member_size<type>::value, "has_member_size failed");
+    BOOST_CHECK_MESSAGE(!boost::unit_test::ut_detail::has_member_begin<type>::value, "has_member_begin failed");
+    BOOST_CHECK_MESSAGE(!boost::unit_test::is_forward_iterable< type >::value, "is_forward_iterable failed");
+  }
+
+
+}
+#endif
+
+
+
 BOOST_AUTO_TEST_CASE( test_basic_value_expression_construction )
 {
     using namespace boost::test_tools;