ceph/src/boost/libs/smart_ptr/test/pointer_cast_test2.cpp

   1 //
   2 //  pointer_cast_test2.cpp - a test for unique_ptr casts
   3 //
   4 //  Copyright 2016 Peter Dimov
   5 //
   6 //  Distributed under the Boost Software License, Version 1.0.
   7 //  See accompanying file LICENSE_1_0.txt or copy at
   8 //  http://www.boost.org/LICENSE_1_0.txt
   9 //
  10
  11 #include <boost/config.hpp>
  12
  13 #if defined( BOOST_NO_CXX11_SMART_PTR )
  14
  15 int main()
  16 {
  17     return 0;
  18 }
  19
  20 #else
  21
  22 #include <boost/pointer_cast.hpp>
  23 #include <boost/core/lightweight_test.hpp>
  24 #include <memory>
  25
  26 struct B1
  27 {
  28 };
  29
  30 struct D1: B1
  31 {
  32     ~D1()
  33     {
  34     }
  35 };
  36
  37 static void test_static_cast()
  38 {
  39     {
  40         std::unique_ptr<int> p1( new int );
  41         int * q1 = p1.get();
  42
  43         std::unique_ptr<int> p2 = boost::static_pointer_cast<int>( std::move( p1 ) );
  44
  45         BOOST_TEST( p1.get() == 0 );
  46         BOOST_TEST_EQ( p2.get(), q1 );
  47     }
  48
  49     {
  50         std::unique_ptr<int> p1( new int );
  51         int * q1 = p1.get();
  52
  53         std::unique_ptr<int const> p2 = boost::static_pointer_cast<int const>( std::move( p1 ) );
  54
  55         BOOST_TEST( p1.get() == 0 );
  56         BOOST_TEST_EQ( p2.get(), q1 );
  57     }
  58
  59     {
  60         std::unique_ptr<int[]> p1( new int[ 1 ] );
  61         int * q1 = p1.get();
  62
  63         std::unique_ptr<int[]> p2 = boost::static_pointer_cast<int[]>( std::move( p1 ) );
  64
  65         BOOST_TEST( p1.get() == 0 );
  66         BOOST_TEST_EQ( p2.get(), q1 );
  67     }
  68
  69     {
  70         std::unique_ptr<int[]> p1( new int[ 1 ] );
  71         int * q1 = p1.get();
  72
  73         std::unique_ptr<int const[]> p2 = boost::static_pointer_cast<int const[]>( std::move( p1 ) );
  74
  75         BOOST_TEST( p1.get() == 0 );
  76         BOOST_TEST_EQ( p2.get(), q1 );
  77     }
  78
  79     {
  80         std::unique_ptr<D1> p1( new D1 );
  81         D1 * q1 = p1.get();
  82
  83         std::unique_ptr<B1> p2 = boost::static_pointer_cast<B1>( std::move( p1 ) );
  84
  85         BOOST_TEST( p1.get() == 0 );
  86         BOOST_TEST_EQ( p2.get(), q1 );
  87
  88         std::unique_ptr<D1> p3 = boost::static_pointer_cast<D1>( std::move( p2 ) );
  89
  90         BOOST_TEST( p2.get() == 0 );
  91         BOOST_TEST_EQ( p3.get(), q1 );
  92     }
  93 }
  94
  95 static void test_const_cast()
  96 {
  97     {
  98         std::unique_ptr<int> p1( new int );
  99         int * q1 = p1.get();
 100
 101         std::unique_ptr<int const> p2 = boost::const_pointer_cast<int const>( std::move( p1 ) );
 102
 103         BOOST_TEST( p1.get() == 0 );
 104         BOOST_TEST_EQ( p2.get(), q1 );
 105
 106         std::unique_ptr<int> p3 = boost::const_pointer_cast<int>( std::move( p2 ) );
 107
 108         BOOST_TEST( p2.get() == 0 );
 109         BOOST_TEST_EQ( p3.get(), q1 );
 110     }
 111
 112     {
 113         std::unique_ptr<int[]> p1( new int[ 1 ] );
 114         int * q1 = p1.get();
 115
 116         std::unique_ptr<int const[]> p2 = boost::const_pointer_cast<int const[]>( std::move( p1 ) );
 117
 118         BOOST_TEST( p1.get() == 0 );
 119         BOOST_TEST_EQ( p2.get(), q1 );
 120
 121         std::unique_ptr<int[]> p3 = boost::const_pointer_cast<int[]>( std::move( p2 ) );
 122
 123         BOOST_TEST( p2.get() == 0 );
 124         BOOST_TEST_EQ( p3.get(), q1 );
 125     }
 126 }
 127
 128 struct B2
 129 {
 130     virtual ~B2()
 131     {
 132     }
 133 };
 134
 135 struct C2
 136 {
 137     virtual ~C2()
 138     {
 139     }
 140 };
 141
 142 struct D2: B2, C2
 143 {
 144 };
 145
 146 static void test_dynamic_cast()
 147 {
 148     {
 149         std::unique_ptr<D2> p1( new D2 );
 150         D2 * q1 = p1.get();
 151
 152         std::unique_ptr<B2> p2 = boost::dynamic_pointer_cast<B2>( std::move( p1 ) );
 153
 154         BOOST_TEST( p1.get() == 0 );
 155         BOOST_TEST_EQ( p2.get(), q1 );
 156     }
 157
 158     {
 159         std::unique_ptr<B2> p1( new D2 );
 160         B2 * q1 = p1.get();
 161
 162         std::unique_ptr<D2> p2 = boost::dynamic_pointer_cast<D2>( std::move( p1 ) );
 163
 164         BOOST_TEST( p1.get() == 0 );
 165         BOOST_TEST_EQ( p2.get(), q1 );
 166     }
 167
 168     {
 169         std::unique_ptr<B2> p1( new B2 );
 170         B2 * q1 = p1.get();
 171
 172         std::unique_ptr<D2> p2 = boost::dynamic_pointer_cast<D2>( std::move( p1 ) );
 173
 174         BOOST_TEST( p2.get() == 0 );
 175         BOOST_TEST_EQ( p1.get(), q1 );
 176     }
 177
 178     {
 179         D2 * q1 = new D2;
 180         std::unique_ptr<B2> p1( q1 );
 181
 182         std::unique_ptr<C2> p2 = boost::dynamic_pointer_cast<C2>( std::move( p1 ) );
 183
 184         BOOST_TEST( p1.get() == 0 );
 185         BOOST_TEST_EQ( p2.get(), q1 );
 186     }
 187 }
 188
 189 static void test_reinterpret_cast()
 190 {
 191     {
 192         std::unique_ptr<int> p1( new int );
 193         void * q1 = p1.get();
 194
 195         std::unique_ptr<char> p2 = boost::reinterpret_pointer_cast<char>( std::move( p1 ) );
 196
 197         BOOST_TEST( p1.get() == 0 );
 198         BOOST_TEST_EQ( p2.get(), q1 );
 199
 200         p1 = boost::reinterpret_pointer_cast<int>( std::move( p2 ) );
 201
 202         BOOST_TEST( p2.get() == 0 );
 203         BOOST_TEST_EQ( p1.get(), q1 );
 204     }
 205
 206     {
 207         std::unique_ptr<int> p1( new int );
 208         void * q1 = p1.get();
 209
 210         std::unique_ptr<char[]> p2 = boost::reinterpret_pointer_cast<char[]>( std::move( p1 ) );
 211
 212         BOOST_TEST( p1.get() == 0 );
 213         BOOST_TEST_EQ( p2.get(), q1 );
 214
 215         p1 = boost::reinterpret_pointer_cast<int>( std::move( p2 ) );
 216
 217         BOOST_TEST( p2.get() == 0 );
 218         BOOST_TEST_EQ( p1.get(), q1 );
 219     }
 220
 221     {
 222         std::unique_ptr<int[]> p1( new int[ 1 ] );
 223         void * q1 = p1.get();
 224
 225         std::unique_ptr<char[]> p2 = boost::reinterpret_pointer_cast<char[]>( std::move( p1 ) );
 226
 227         BOOST_TEST( p1.get() == 0 );
 228         BOOST_TEST_EQ( p2.get(), q1 );
 229
 230         p1 = boost::reinterpret_pointer_cast<int[]>( std::move( p2 ) );
 231
 232         BOOST_TEST( p2.get() == 0 );
 233         BOOST_TEST_EQ( p1.get(), q1 );
 234     }
 235 }
 236
 237 int main()
 238 {
 239     test_static_cast();
 240     test_const_cast();
 241     test_dynamic_cast();
 242     test_reinterpret_cast();
 243
 244     return boost::report_errors();
 245 }
 246
 247 #endif