summaryrefslogtreecommitdiff
path: root/src/third_party/boost-1.60.0/libs/utility/compressed_pair_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/third_party/boost-1.60.0/libs/utility/compressed_pair_test.cpp')
-rw-r--r--src/third_party/boost-1.60.0/libs/utility/compressed_pair_test.cpp395
1 files changed, 395 insertions, 0 deletions
diff --git a/src/third_party/boost-1.60.0/libs/utility/compressed_pair_test.cpp b/src/third_party/boost-1.60.0/libs/utility/compressed_pair_test.cpp
new file mode 100644
index 00000000000..7687f0a0aa4
--- /dev/null
+++ b/src/third_party/boost-1.60.0/libs/utility/compressed_pair_test.cpp
@@ -0,0 +1,395 @@
+// boost::compressed_pair test program
+
+// (C) Copyright John Maddock 2000.
+// Use, modification and distribution are subject to 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).
+
+// standalone test program for <boost/compressed_pair.hpp>
+// Revised 03 Oct 2000:
+// Enabled tests for VC6.
+
+#include <iostream>
+#include <typeinfo>
+#include <cassert>
+
+#include <boost/compressed_pair.hpp>
+#include <boost/test/test_tools.hpp>
+
+using namespace boost;
+
+struct empty_UDT
+{
+ ~empty_UDT(){};
+ empty_UDT& operator=(const empty_UDT&){ return *this; }
+ bool operator==(const empty_UDT&)const
+ { return true; }
+};
+struct empty_POD_UDT
+{
+ empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; }
+ bool operator==(const empty_POD_UDT&)const
+ { return true; }
+};
+
+struct non_empty1
+{
+ int i;
+ non_empty1() : i(1){}
+ non_empty1(int v) : i(v){}
+ friend bool operator==(const non_empty1& a, const non_empty1& b)
+ { return a.i == b.i; }
+};
+
+struct non_empty2
+{
+ int i;
+ non_empty2() : i(3){}
+ non_empty2(int v) : i(v){}
+ friend bool operator==(const non_empty2& a, const non_empty2& b)
+ { return a.i == b.i; }
+};
+
+#ifdef __GNUC__
+using std::swap;
+#endif
+
+template <class T1, class T2>
+struct compressed_pair_tester
+{
+ // define the types we need:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ // define our test proc:
+ static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
+{
+#ifndef __GNUC__
+ // gcc 2.90 can't cope with function scope using
+ // declarations, and generates an internal compiler error...
+ using std::swap;
+#endif
+ // default construct:
+ boost::compressed_pair<T1,T2> cp1;
+ // first param construct:
+ boost::compressed_pair<T1,T2> cp2(p1);
+ cp2.second() = p2;
+ BOOST_CHECK(cp2.first() == p1);
+ BOOST_CHECK(cp2.second() == p2);
+ // second param construct:
+ boost::compressed_pair<T1,T2> cp3(p2);
+ cp3.first() = p1;
+ BOOST_CHECK(cp3.second() == p2);
+ BOOST_CHECK(cp3.first() == p1);
+ // both param construct:
+ boost::compressed_pair<T1,T2> cp4(p1, p2);
+ BOOST_CHECK(cp4.first() == p1);
+ BOOST_CHECK(cp4.second() == p2);
+ boost::compressed_pair<T1,T2> cp5(p3, p4);
+ BOOST_CHECK(cp5.first() == p3);
+ BOOST_CHECK(cp5.second() == p4);
+ // check const members:
+ const boost::compressed_pair<T1,T2>& cpr1 = cp4;
+ BOOST_CHECK(cpr1.first() == p1);
+ BOOST_CHECK(cpr1.second() == p2);
+
+ // copy construct:
+ boost::compressed_pair<T1,T2> cp6(cp4);
+ BOOST_CHECK(cp6.first() == p1);
+ BOOST_CHECK(cp6.second() == p2);
+ // assignment:
+ cp1 = cp4;
+ BOOST_CHECK(cp1.first() == p1);
+ BOOST_CHECK(cp1.second() == p2);
+ cp1 = cp5;
+ BOOST_CHECK(cp1.first() == p3);
+ BOOST_CHECK(cp1.second() == p4);
+ // swap:
+ cp4.swap(cp5);
+ BOOST_CHECK(cp4.first() == p3);
+ BOOST_CHECK(cp4.second() == p4);
+ BOOST_CHECK(cp5.first() == p1);
+ BOOST_CHECK(cp5.second() == p2);
+ swap(cp4,cp5);
+ BOOST_CHECK(cp4.first() == p1);
+ BOOST_CHECK(cp4.second() == p2);
+ BOOST_CHECK(cp5.first() == p3);
+ BOOST_CHECK(cp5.second() == p4);
+}
+
+//
+// tests for case where one or both
+// parameters are reference types:
+//
+template <class T1, class T2>
+struct compressed_pair_reference_tester
+{
+ // define the types we need:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ // define our test proc:
+ static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
+{
+#ifndef __GNUC__
+ // gcc 2.90 can't cope with function scope using
+ // declarations, and generates an internal compiler error...
+ using std::swap;
+#endif
+ // both param construct:
+ boost::compressed_pair<T1,T2> cp4(p1, p2);
+ BOOST_CHECK(cp4.first() == p1);
+ BOOST_CHECK(cp4.second() == p2);
+ boost::compressed_pair<T1,T2> cp5(p3, p4);
+ BOOST_CHECK(cp5.first() == p3);
+ BOOST_CHECK(cp5.second() == p4);
+ // check const members:
+ const boost::compressed_pair<T1,T2>& cpr1 = cp4;
+ BOOST_CHECK(cpr1.first() == p1);
+ BOOST_CHECK(cpr1.second() == p2);
+
+ // copy construct:
+ boost::compressed_pair<T1,T2> cp6(cp4);
+ BOOST_CHECK(cp6.first() == p1);
+ BOOST_CHECK(cp6.second() == p2);
+ // assignment:
+ // VC6 bug:
+ // When second() is an empty class, VC6 performs the
+ // assignment by doing a memcpy - even though the empty
+ // class is really a zero sized base class, the result
+ // is that the memory of first() gets trampled over.
+ // Similar arguments apply to the case that first() is
+ // an empty base class.
+ // Strangely the problem is dependent upon the compiler
+ // settings - some generate the problem others do not.
+ cp4.first() = p3;
+ cp4.second() = p4;
+ BOOST_CHECK(cp4.first() == p3);
+ BOOST_CHECK(cp4.second() == p4);
+}
+//
+// supplimentary tests for case where first arg only is a reference type:
+//
+template <class T1, class T2>
+struct compressed_pair_reference1_tester
+{
+ // define the types we need:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ // define our test proc:
+ static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_reference1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ // first param construct:
+ boost::compressed_pair<T1,T2> cp2(p1);
+ cp2.second() = p2;
+ BOOST_CHECK(cp2.first() == p1);
+ BOOST_CHECK(cp2.second() == p2);
+#endif
+}
+//
+// supplimentary tests for case where second arg only is a reference type:
+//
+template <class T1, class T2>
+struct compressed_pair_reference2_tester
+{
+ // define the types we need:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ // define our test proc:
+ static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_reference2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ // second param construct:
+ boost::compressed_pair<T1,T2> cp3(p2);
+ cp3.first() = p1;
+ BOOST_CHECK(cp3.second() == p2);
+ BOOST_CHECK(cp3.first() == p1);
+#endif
+}
+
+//
+// tests for where one or the other parameter is an array:
+//
+template <class T1, class T2>
+struct compressed_pair_array1_tester
+{
+ // define the types we need:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ // define our test proc:
+ static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_array1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
+ // default construct:
+ boost::compressed_pair<T1,T2> cp1;
+ // second param construct:
+ boost::compressed_pair<T1,T2> cp3(p2);
+ cp3.first()[0] = p1[0];
+ BOOST_CHECK(cp3.second() == p2);
+ BOOST_CHECK(cp3.first()[0] == p1[0]);
+ // check const members:
+ const boost::compressed_pair<T1,T2>& cpr1 = cp3;
+ BOOST_CHECK(cpr1.first()[0] == p1[0]);
+ BOOST_CHECK(cpr1.second() == p2);
+
+ BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
+}
+
+template <class T1, class T2>
+struct compressed_pair_array2_tester
+{
+ // define the types we need:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ // define our test proc:
+ static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_array2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
+ // default construct:
+ boost::compressed_pair<T1,T2> cp1;
+ // first param construct:
+ boost::compressed_pair<T1,T2> cp2(p1);
+ cp2.second()[0] = p2[0];
+ BOOST_CHECK(cp2.first() == p1);
+ BOOST_CHECK(cp2.second()[0] == p2[0]);
+ // check const members:
+ const boost::compressed_pair<T1,T2>& cpr1 = cp2;
+ BOOST_CHECK(cpr1.first() == p1);
+ BOOST_CHECK(cpr1.second()[0] == p2[0]);
+
+ BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
+}
+
+template <class T1, class T2>
+struct compressed_pair_array_tester
+{
+ // define the types we need:
+ typedef T1 first_type;
+ typedef T2 second_type;
+ typedef typename call_traits<first_type>::param_type first_param_type;
+ typedef typename call_traits<second_type>::param_type second_param_type;
+ // define our test proc:
+ static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_array_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
+ // default construct:
+ boost::compressed_pair<T1,T2> cp1;
+ cp1.first()[0] = p1[0];
+ cp1.second()[0] = p2[0];
+ BOOST_CHECK(cp1.first()[0] == p1[0]);
+ BOOST_CHECK(cp1.second()[0] == p2[0]);
+ // check const members:
+ const boost::compressed_pair<T1,T2>& cpr1 = cp1;
+ BOOST_CHECK(cpr1.first()[0] == p1[0]);
+ BOOST_CHECK(cpr1.second()[0] == p2[0]);
+
+ BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
+ BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
+}
+
+int test_main(int, char *[])
+{
+ // declare some variables to pass to the tester:
+ non_empty1 ne1(2);
+ non_empty1 ne2(3);
+ non_empty2 ne3(4);
+ non_empty2 ne4(5);
+ empty_POD_UDT e1;
+ empty_UDT e2;
+
+ // T1 != T2, both non-empty
+ compressed_pair_tester<non_empty1,non_empty2>::test(ne1, ne3, ne2, ne4);
+ // T1 != T2, T2 empty
+ compressed_pair_tester<non_empty1,empty_POD_UDT>::test(ne1, e1, ne2, e1);
+ // T1 != T2, T1 empty
+ compressed_pair_tester<empty_POD_UDT,non_empty2>::test(e1, ne3, e1, ne4);
+ // T1 != T2, both empty
+ compressed_pair_tester<empty_POD_UDT,empty_UDT>::test(e1, e2, e1, e2);
+ // T1 == T2, both non-empty
+ compressed_pair_tester<non_empty1,non_empty1>::test(ne1, ne1, ne2, ne2);
+ // T1 == T2, both empty
+ compressed_pair_tester<empty_UDT,empty_UDT>::test(e2, e2, e2, e2);
+
+
+ // test references:
+
+ // T1 != T2, both non-empty
+ compressed_pair_reference_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
+ compressed_pair_reference_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
+ compressed_pair_reference1_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
+ compressed_pair_reference2_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
+ // T1 != T2, T2 empty
+ compressed_pair_reference_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
+ compressed_pair_reference1_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
+ // T1 != T2, T1 empty
+ compressed_pair_reference_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
+ compressed_pair_reference2_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
+ // T1 == T2, both non-empty
+ compressed_pair_reference_tester<non_empty1&,non_empty1&>::test(ne1, ne1, ne2, ne2);
+
+ // tests arrays:
+ non_empty1 nea1[2];
+ non_empty1 nea2[2];
+ non_empty2 nea3[2];
+ non_empty2 nea4[2];
+ nea1[0] = non_empty1(5);
+ nea2[0] = non_empty1(6);
+ nea3[0] = non_empty2(7);
+ nea4[0] = non_empty2(8);
+
+ // T1 != T2, both non-empty
+ compressed_pair_array1_tester<non_empty1[2],non_empty2>::test(nea1, ne3, nea2, ne4);
+ compressed_pair_array2_tester<non_empty1,non_empty2[2]>::test(ne1, nea3, ne2, nea4);
+ compressed_pair_array_tester<non_empty1[2],non_empty2[2]>::test(nea1, nea3, nea2, nea4);
+ // T1 != T2, T2 empty
+ compressed_pair_array1_tester<non_empty1[2],empty_POD_UDT>::test(nea1, e1, nea2, e1);
+ // T1 != T2, T1 empty
+ compressed_pair_array2_tester<empty_POD_UDT,non_empty2[2]>::test(e1, nea3, e1, nea4);
+ // T1 == T2, both non-empty
+ compressed_pair_array_tester<non_empty1[2],non_empty1[2]>::test(nea1, nea1, nea2, nea2);
+ return 0;
+}
+
+
+unsigned int expected_failures = 0;
+
+
+
+
+
View Lorry Controller Status