shared_ptr_test.cpp

来自「Boost provides free peer-reviewed portab」· C++ 代码 · 共 634 行 · 第 1/2 页

   BOOST_TEST(p.get() != 0);
   BOOST_TEST(p.get()->id() == 1);
}

template<class T, class A, class D> 
void test_is_Y(shared_ptr<T, A, D> const & p)
{
   BOOST_TEST(p->id() == 2);
   BOOST_TEST((*p).id() == 2);
}

template<class T, class A, class D> 
void test_is_Y(weak_ptr<T, A, D> const & p)
{
   shared_ptr<T, A, D> q = p.lock();
   BOOST_TEST(q.get() != 0);
   BOOST_TEST(q->id() == 2);
}

template<class T, class T2> 
void test_eq(T const & a, T2 const & b)
{
   BOOST_TEST(a == b);
   BOOST_TEST(!(a != b));
   BOOST_TEST(!(a < b));
   BOOST_TEST(!(b < a));
}

template<class T, class T2> 
void test_ne(T const & a, T2 const & b)
{
   BOOST_TEST(!(a == b));
   BOOST_TEST(a != b);
   BOOST_TEST(a < b || b < a);
   BOOST_TEST(!(a < b && b < a));
}

template<class T, class U, class A, class D, class D2>
void test_shared(weak_ptr<T, A, D> const & a, weak_ptr<U, A, D2> const & b)
{
   BOOST_TEST(!(a < b));
   BOOST_TEST(!(b < a));
}

template<class T, class U, class A, class D, class D2>
void test_nonshared(weak_ptr<T, A, D> const & a, weak_ptr<U, A, D2> const & b)
{
   BOOST_TEST(a < b || b < a);
   BOOST_TEST(!(a < b && b < a));
}

template<class T, class U>
void test_eq2(T const & a, U const & b)
{
   BOOST_TEST(a == b);
   BOOST_TEST(!(a != b));
}

template<class T, class U>
void test_ne2(T const & a, U const & b)
{
   BOOST_TEST(!(a == b));
   BOOST_TEST(a != b);
}

template<class T, class A, class D>
void test_is_zero(shared_ptr<T, A, D> const & p)
{
   BOOST_TEST(!p);
   BOOST_TEST(p.get() == 0);
}

template<class T, class A, class D>
void test_is_nonzero(shared_ptr<T, A, D> const & p)
{
   // p? true: false is used to test p in a boolean context.
   // BOOST_TEST(p) is not guaranteed to test the conversion,
   // as the macro might test !!p instead.
   BOOST_TEST(p? true: false);
   BOOST_TEST(p.get() != 0);
}

int basic_shared_ptr_test()
{
   typedef allocator<void, managed_shared_memory::segment_manager>
      v_allocator_t;

   typedef deleter<X, managed_shared_memory::segment_manager>
      x_deleter_t;

   typedef deleter<Y, managed_shared_memory::segment_manager>
      y_deleter_t;

   typedef shared_ptr<X, v_allocator_t, x_deleter_t> x_shared_ptr;

   typedef shared_ptr<Y, v_allocator_t, y_deleter_t> y_shared_ptr;

   typedef weak_ptr<X, v_allocator_t, x_deleter_t> x_weak_ptr;

   typedef weak_ptr<Y, v_allocator_t, y_deleter_t> y_weak_ptr;

   std::string process_name;
   test::get_process_id_name(process_name);

   shared_memory_object::remove(process_name.c_str());
   {
      managed_shared_memory shmem(create_only, process_name.c_str(), 10000);
      {
         v_allocator_t  v_allocator (shmem.get_segment_manager());
         x_deleter_t    x_deleter   (shmem.get_segment_manager());
         y_deleter_t    y_deleter   (shmem.get_segment_manager());

         y_shared_ptr p (shmem.construct<Y>(anonymous_instance)(), v_allocator, y_deleter);
         x_shared_ptr p2(shmem.construct<X>(anonymous_instance)(), v_allocator, x_deleter);

         test_is_nonzero(p);
         test_is_nonzero(p2);
         test_is_Y(p);
         test_is_X(p2);
         test_ne(p, p2);

         {
            shared_ptr<X, v_allocator_t, y_deleter_t> q(p);
            test_eq(p, q);
         }

         y_shared_ptr p3 (dynamic_pointer_cast<Y>(p));
         shared_ptr<Y, v_allocator_t, x_deleter_t> p4 (dynamic_pointer_cast<Y>(p2));
         test_is_nonzero(p3);
         test_is_zero(p4);
         BOOST_TEST(p.use_count() == 2);
         BOOST_TEST(p2.use_count() == 1);
         BOOST_TEST(p3.use_count() == 2);
         test_is_Y(p3);
         test_eq2(p, p3);
         test_ne2(p2, p4);

         shared_ptr<void, v_allocator_t, y_deleter_t> p5(p);

         test_is_nonzero(p5);
         test_eq2(p, p5);
         BOOST_TEST(p5.use_count() == 3);

         x_weak_ptr wp1(p2);

         BOOST_TEST(!wp1.expired());
         BOOST_TEST(wp1.use_count() != 0);

         p.reset();
         p2.reset();
         p3.reset();
         p4.reset();

         test_is_zero(p);
         test_is_zero(p2);
         test_is_zero(p3);
         test_is_zero(p4);

         BOOST_TEST(p5.use_count() == 1);
         BOOST_TEST(wp1.expired());
         BOOST_TEST(wp1.use_count() == 0);

         try{
            x_shared_ptr sp1(wp1);
            BOOST_ERROR("shared_ptr<X, A, D> sp1(wp1) failed to throw");
         }
         catch(boost::interprocess::bad_weak_ptr const &)
         {}

         test_is_zero(wp1.lock());

         weak_ptr<X, v_allocator_t, y_deleter_t> wp2 = static_pointer_cast<X>(p5);

         BOOST_TEST(wp2.use_count() == 1);
         test_is_Y(wp2);
         test_nonshared(wp1, wp2);

         // Scoped to not affect the subsequent use_count() tests.
         {
            shared_ptr<X, v_allocator_t, y_deleter_t> sp2(wp2);
            test_is_nonzero(wp2.lock());
         }

         y_weak_ptr wp3 = dynamic_pointer_cast<Y>(wp2.lock());

         BOOST_TEST(wp3.use_count() == 1);
         test_shared(wp2, wp3);

         weak_ptr<X, v_allocator_t, y_deleter_t> wp4(wp3);

         BOOST_TEST(wp4.use_count() == 1);
         test_shared(wp2, wp4);

         wp1 = p2;
         test_is_zero(wp1.lock());

         wp1 = p4;

         x_weak_ptr wp5;

         bool b1 = wp1 < wp5;
         bool b2 = wp5 < wp1;

         y_shared_ptr p6 = static_pointer_cast<Y>(p5);
         p5.reset();
         p6.reset();

         BOOST_TEST(wp1.use_count() == 0);
         BOOST_TEST(wp2.use_count() == 0);
         BOOST_TEST(wp3.use_count() == 0);

         // Test operator< stability for std::set< weak_ptr<> >
         // Thanks to Joe Gottman for pointing this out
         BOOST_TEST(b1 == (wp1 < wp5));
         BOOST_TEST(b2 == (wp5 < wp1));
      }

      BOOST_TEST(cnt == 0);
   }
   shared_memory_object::remove(process_name.c_str());
   return boost::report_errors();
}

struct alias_tester
{
    int v_;

    explicit alias_tester( int v ): v_( v )
    {
    }

    ~alias_tester()
    {
        v_ = 0;
    }
};

void test_alias()
{
   typedef allocator<void, managed_shared_memory::segment_manager>
      v_allocator_t;

   typedef deleter<alias_tester, managed_shared_memory::segment_manager>
      alias_tester_deleter_t;

   typedef deleter<int, managed_shared_memory::segment_manager>
      int_deleter_t;

   typedef shared_ptr<alias_tester, v_allocator_t, alias_tester_deleter_t> alias_tester_shared_ptr;

   typedef shared_ptr<int, v_allocator_t, int_deleter_t> int_shared_ptr;
   typedef shared_ptr<const int, v_allocator_t, int_deleter_t> const_int_shared_ptr;
   typedef shared_ptr<volatile int, v_allocator_t, int_deleter_t> volatile_int_shared_ptr;

   std::string process_name;
   test::get_process_id_name(process_name);

   shared_memory_object::remove(process_name.c_str());
   {
      managed_shared_memory shmem(create_only, process_name.c_str(), 10000);

      {
         int m = 0;
         int_shared_ptr p;
         int_shared_ptr p2( p, &m );

         BOOST_TEST( detail::get_pointer(p2.get()) == &m );
         BOOST_TEST( p2? true: false );
         BOOST_TEST( !!p2 );
         BOOST_TEST( p2.use_count() == p.use_count() );
         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );

         p2.reset( p, static_cast<int*>(0) );

         BOOST_TEST( p2.get() == 0 );

         BOOST_TEST( p2? false: true );
         BOOST_TEST( !p2 );
         BOOST_TEST( p2.use_count() == p.use_count() );
         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
      }

      {
         int m = 0;
         int_shared_ptr p(make_managed_shared_ptr
            (shmem.construct<int>(anonymous_instance)(), shmem));
         const_int_shared_ptr p2( p, &m );

         BOOST_TEST( detail::get_pointer(p2.get()) == &m );
         BOOST_TEST( p2? true: false );
         BOOST_TEST( !!p2 );
         BOOST_TEST( p2.use_count() == p.use_count() );
         BOOST_TEST( !( p < p2 ) && !( p2 < p ) );
      }
   }
   shared_memory_object::remove(process_name.c_str());
}


int main()
{
   if(0 != simple_test())
      return 1;

   if(0 != string_shared_ptr_vector_insertion_test())
      return 1;

   if(0 != basic_shared_ptr_test())
      return 1;

   test_alias();

   return 0;
}

#include <boost/interprocess/detail/config_end.hpp>