ceph/src/boost/libs/container/test/pair_test.cpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
   4 // Software License, Version 1.0. (See accompanying file
   5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // See http://www.boost.org/libs/container for documentation.
   8 //
   9 //////////////////////////////////////////////////////////////////////////////
  10 #include <boost/container/detail/pair.hpp>
  11 #include "movable_int.hpp"
  12 #include "emplace_test.hpp"
  13 #include<boost/move/utility_core.hpp>
  14 #include<boost/move/detail/fwd_macros.hpp>
  15 #include<boost/core/lightweight_test.hpp>
  16
  17 //non_copymovable_int
  18 //copyable_int
  19 //movable_int
  20 //movable_and_copyable_int
  21
  22
  23 #include <boost/tuple/tuple.hpp>
  24
  25 #if !defined(BOOST_NO_CXX11_HDR_TUPLE) || (defined(BOOST_MSVC) && (BOOST_MSVC == 1700 || BOOST_MSVC == 1600))
  26 #define BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE
  27 #endif
  28
  29 #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
  30 #include <tuple>
  31 #endif
  32
  33 using namespace ::boost::container;
  34
  35 int main ()
  36 {
  37    {
  38       dtl::pair<test::non_copymovable_int, test::non_copymovable_int> p1;
  39       dtl::pair<test::copyable_int, test::copyable_int> p2;
  40       dtl::pair<test::movable_int, test::movable_int> p3;
  41       dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4;
  42    }
  43    {  //Constructible from two values
  44       dtl::pair<test::non_copymovable_int, test::non_copymovable_int> p1(1, 2);
  45       dtl::pair<test::copyable_int, test::copyable_int> p2(1, 2);
  46       dtl::pair<test::movable_int, test::movable_int> p3(1, 2);
  47       dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4(1, 2);
  48    }
  49
  50    {  //Constructible from internal types
  51       dtl::pair<test::copyable_int, test::copyable_int> p2(test::copyable_int(1), test::copyable_int(2));
  52       {
  53          test::movable_int a(1), b(2);
  54          dtl::pair<test::movable_int, test::movable_int> p3(::boost::move(a), ::boost::move(b));
  55       }
  56       {
  57          test::movable_and_copyable_int a(1), b(2);
  58          dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4(::boost::move(a), ::boost::move(b));
  59       }
  60    }
  61    {  //piecewise construct from boost tuple
  62       using namespace boost::tuples;
  63       {
  64          boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<>());
  65          BOOST_TEST(p.first == 0);
  66          BOOST_TEST(p.second == 0.f);
  67       }
  68       {
  69          boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<float>(2.f));
  70          BOOST_TEST(p.first == 0);
  71          BOOST_TEST(p.second == 2.f);
  72       }
  73       {
  74          boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<int>(2), tuple<float>(1.f));
  75          BOOST_TEST(p.first == 2);
  76          BOOST_TEST(p.second == 1.f);
  77       }
  78       {
  79          boost::container::dtl::pair
  80             < boost::container::dtl::pair<int, float>
  81             , boost::container::dtl::pair<double, char>
  82             > p(piecewise_construct, tuple<int, float>(3, 4.f), tuple<double, char>(8.,'a'));
  83          BOOST_TEST(p.first.first   == 3);
  84          BOOST_TEST(p.first.second  == 4.f);
  85          BOOST_TEST(p.second.first  == 8.);
  86          BOOST_TEST(p.second.second == 'a');
  87       }
  88       {
  89          boost::container::dtl::pair
  90             < tuple<int, float, double>
  91             , char
  92             > p(piecewise_construct, tuple<int, float, double>(3, 16.f, 32.), tuple<char>('b'));
  93          BOOST_TEST(p.first.get<0>() == 3);
  94          BOOST_TEST(p.first.get<1>() == 16.f);
  95          BOOST_TEST(p.first.get<2>() == 32.);
  96          BOOST_TEST(p.second == 'b');
  97       }
  98    }
  99    #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
 100    {  //piecewise construct from std tuple
 101       using std::tuple;
 102       {
 103          boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<>());
 104          BOOST_TEST(p.first == 0);
 105          BOOST_TEST(p.second == 0.f);
 106       }
 107       {
 108          boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<float>(2.f));
 109          BOOST_TEST(p.first == 0);
 110          BOOST_TEST(p.second == 2.f);
 111       }
 112       {
 113          boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<int>(2), tuple<float>(1.f));
 114          BOOST_TEST(p.first == 2);
 115          BOOST_TEST(p.second == 1.f);
 116       }
 117       {
 118          boost::container::dtl::pair
 119             < boost::container::dtl::pair<int, float>
 120             , boost::container::dtl::pair<double, char>
 121             > p(piecewise_construct, tuple<int, float>(3, 4.f), tuple<double, char>(8.,'a'));
 122          BOOST_TEST(p.first.first   == 3);
 123          BOOST_TEST(p.first.second  == 4.f);
 124          BOOST_TEST(p.second.first  == 8.);
 125          BOOST_TEST(p.second.second == 'a');
 126       }
 127       {
 128          boost::container::dtl::pair
 129             < tuple<int, float, double>
 130             , char
 131             > p(piecewise_construct, tuple<int, float, double>(3, 16.f, 32.), tuple<char>('b'));
 132          BOOST_TEST(std::get<0>(p.first) == 3);
 133          BOOST_TEST(std::get<1>(p.first) == 16.f);
 134          BOOST_TEST(std::get<2>(p.first) == 32.);
 135          BOOST_TEST(p.second == 'b');
 136       }
 137       #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 138       typedef dtl::pair<test::movable_int, test::movable_int> movable_pair_t;
 139       typedef dtl::pair<movable_pair_t, movable_pair_t> movable_pair_pair_t;
 140       test::movable_int a(1), b(2), c(3), d(4);
 141       movable_pair_pair_t p( piecewise_construct
 142                            , dtl::forward_as_tuple_impl(boost::move(a), boost::move(b))
 143                            , dtl::forward_as_tuple_impl(boost::move(c), boost::move(d))
 144                            );
 145       BOOST_TEST(p.first.first   == 1);
 146       BOOST_TEST(p.first.second  == 2);
 147       BOOST_TEST(p.second.first  == 3);
 148       BOOST_TEST(p.second.second == 4);
 149       #endif
 150    }
 151    #endif   //#!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
 152    return ::boost::report_errors();
 153 }