1 files changed, 79 insertions, 0 deletions
diff --git a/libs/lambda/test/is_instance_of_test.cpp b/libs/lambda/test/is_instance_of_test.cpp
new file mode 100644
index 000000000..d1c57b364
--- /dev/null
+++ b/libs/lambda/test/is_instance_of_test.cpp
@@ -0,0 +1,79 @@
+// is_instance_of_test.cpp -- The Boost Lambda Library ------------------
+//
+// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see www.boost.org
+
+// -----------------------------------------------------------------------
+
+
+#include <boost/test/minimal.hpp>    // see "Header Implementation Option"
+ 
+
+#include "boost/lambda/detail/is_instance_of.hpp"
+
+#include <iostream>
+
+template <class T1> struct A1 {};
+template <class T1, class T2> struct A2 {};
+template <class T1, class T2, class T3> struct A3 {};
+template <class T1, class T2, class T3, class T4> struct A4 {};
+ 
+class B1 : public A1<int> {};
+class B2 : public A2<int,int> {};
+class B3 : public A3<int,int,int> {};
+class B4 : public A4<int,int,int,int> {};
+
+// classes that are convertible to classes that derive from A instances 
+// This is not enough to make the test succeed
+
+class C1 { public: operator A1<int>() { return A1<int>(); } };
+class C2 { public: operator B2() { return B2(); } };
+class C3 { public: operator B3() { return B3(); } };
+class C4 { public: operator B4() { return B4(); } };
+ 
+// test that the result is really a constant
+// (in an alternative implementation, gcc 3.0.2. claimed that it was 
+// a non-constant)
+template <bool b> class X {};
+// this should compile 
+X<boost::lambda::is_instance_of_2<int, A2>::value> x;
+
+
+int test_main(int, char *[]) {
+
+using boost::lambda::is_instance_of_1;
+using boost::lambda::is_instance_of_2;
+using boost::lambda::is_instance_of_3;
+using boost::lambda::is_instance_of_4;
+
+
+BOOST_CHECK((is_instance_of_1<B1, A1>::value == true));
+BOOST_CHECK((is_instance_of_1<A1<float>, A1>::value == true));
+BOOST_CHECK((is_instance_of_1<int, A1>::value == false));
+BOOST_CHECK((is_instance_of_1<C1, A1>::value == false));
+
+BOOST_CHECK((is_instance_of_2<B2, A2>::value == true));
+BOOST_CHECK((is_instance_of_2<A2<int, float>, A2>::value == true));
+BOOST_CHECK((is_instance_of_2<int, A2>::value == false));
+BOOST_CHECK((is_instance_of_2<C2, A2>::value == false));
+
+BOOST_CHECK((is_instance_of_3<B3, A3>::value == true));
+BOOST_CHECK((is_instance_of_3<A3<int, float, char>, A3>::value == true));
+BOOST_CHECK((is_instance_of_3<int, A3>::value == false));
+BOOST_CHECK((is_instance_of_3<C3, A3>::value == false));
+
+BOOST_CHECK((is_instance_of_4<B4, A4>::value == true));
+BOOST_CHECK((is_instance_of_4<A4<int, float, char, double>, A4>::value == true));
+BOOST_CHECK((is_instance_of_4<int, A4>::value == false));
+BOOST_CHECK((is_instance_of_4<C4, A4>::value == false));
+
+return 0;
+
+}
+