boostorg/move
1
0
Fork 1
mirror of https://github.com/boostorg/move.git synced 2025-08-03 14:14:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

Simplified and improved unique_ptr implementation:

Browse Source 
- No array specialization to avoid code duplication
- Constructible and assignable from literal zero
This commit is contained in:
Ion Gaztañaga
2014-08-27 23:21:36 +02:00
parent 6b2982a385
commit 364ee17476
7 changed files with 571 additions and 695 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
doc/Jamfile.v2
View File

@@ -24,7 +24,12 @@ doxygen autodoc
<doxygen:param>"PREDEFINED=\"BOOST_MOVE_DOXYGEN_INVOKED\" \\ <doxygen:param>"PREDEFINED=\"BOOST_MOVE_DOXYGEN_INVOKED\" \\
\"BOOST_MOVE_SEEDOC(T)=see_documentation\" \\ \"BOOST_MOVE_SEEDOC(T)=see_documentation\" \\
\"BOOST_RV_REF(T)=T&&\" \\ \"BOOST_RV_REF(T)=T&&\" \\
\"BOOST_RV_REF_BEG=\" \\
\"BOOST_RV_REF_END=&&\" \\
\"BOOST_FWD_REF(T)=T&&\" \\ \"BOOST_FWD_REF(T)=T&&\" \\
\"BOOST_MOVE_DOC0PTR(T)=std::nullptr_t\" \\
\"BOOST_MOVE_DOC1ST(T1, T2)=T1\" \\
\"BOOST_MOVE_DOCIGN(T1) \"\\
" "
; ;

84
include/boost/move/detail/meta_utils.hpp
View File

@@ -313,6 +313,15 @@ struct add_lvalue_reference<const volatile void>
typedef const volatile void type; typedef const volatile void type;
}; };
template<class T>
struct add_const_lvalue_reference
{
typedef typename remove_reference<T>::type t_unreferenced;
typedef typename add_const<t_unreferenced>::type t_unreferenced_const;
typedef typename add_lvalue_reference
<t_unreferenced_const>::type type;
};
////////////////////////////////////// //////////////////////////////////////
// is_same // is_same
@@ -483,7 +492,8 @@ struct pointer_type_imp<T, D, false>
template <class T, class D> template <class T, class D>
struct pointer_type struct pointer_type
{ {
typedef typename pointer_type_imp<T, typename remove_reference<D>::type>::type type; typedef typename pointer_type_imp
<typename remove_extent<T>::type, typename remove_reference<D>::type>::type type;
}; };
////////////////////////////////////// //////////////////////////////////////
@@ -517,7 +527,7 @@ class is_convertible
#endif #endif
////////////////////////////////////// //////////////////////////////////////
// is_unary_or_binary_function // is_unary_function
////////////////////////////////////// //////////////////////////////////////
#if defined(BOOST_MSVC) || defined(__BORLANDC_) #if defined(BOOST_MSVC) || defined(__BORLANDC_)
#define BOOST_MOVE_TT_DECL __cdecl #define BOOST_MOVE_TT_DECL __cdecl
@@ -530,120 +540,86 @@ class is_convertible
#endif #endif
template <typename T> template <typename T>
struct is_unary_or_binary_function_impl struct is_unary_function_impl
{ static const bool value = false; }; { static const bool value = false; };
// avoid duplicate definitions of is_unary_or_binary_function_impl // avoid duplicate definitions of is_unary_function_impl
#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS #ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R> template <typename R>
struct is_unary_or_binary_function_impl<R (*)()> struct is_unary_function_impl<R (*)()>
{ static const bool value = true; }; { static const bool value = true; };
template <typename R> template <typename R>
struct is_unary_or_binary_function_impl<R (*)(...)> struct is_unary_function_impl<R (*)(...)>
{ static const bool value = true; }; { static const bool value = true; };
#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS #else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R> template <typename R>
struct is_unary_or_binary_function_impl<R (__stdcall*)()> struct is_unary_function_impl<R (__stdcall*)()>
{ static const bool value = true; }; { static const bool value = true; };
#ifndef _MANAGED #ifndef _MANAGED
template <typename R> template <typename R>
struct is_unary_or_binary_function_impl<R (__fastcall*)()> struct is_unary_function_impl<R (__fastcall*)()>
{ static const bool value = true; }; { static const bool value = true; };
#endif #endif
template <typename R> template <typename R>
struct is_unary_or_binary_function_impl<R (__cdecl*)()> struct is_unary_function_impl<R (__cdecl*)()>
{ static const bool value = true; }; { static const bool value = true; };
template <typename R> template <typename R>
struct is_unary_or_binary_function_impl<R (__cdecl*)(...)> struct is_unary_function_impl<R (__cdecl*)(...)>
{ static const bool value = true; }; { static const bool value = true; };
#endif #endif
// avoid duplicate definitions of is_unary_or_binary_function_impl // avoid duplicate definitions of is_unary_function_impl
#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS #ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R, class T0> template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (*)(T0)> struct is_unary_function_impl<R (*)(T0)>
{ static const bool value = true; }; { static const bool value = true; };
template <typename R, class T0> template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (*)(T0...)> struct is_unary_function_impl<R (*)(T0...)>
{ static const bool value = true; }; { static const bool value = true; };
#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS #else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R, class T0> template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__stdcall*)(T0)> struct is_unary_function_impl<R (__stdcall*)(T0)>
{ static const bool value = true; }; { static const bool value = true; };
#ifndef _MANAGED #ifndef _MANAGED
template <typename R, class T0> template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__fastcall*)(T0)> struct is_unary_function_impl<R (__fastcall*)(T0)>
{ static const bool value = true; }; { static const bool value = true; };
#endif #endif
template <typename R, class T0> template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0)> struct is_unary_function_impl<R (__cdecl*)(T0)>
{ static const bool value = true; }; { static const bool value = true; };
template <typename R, class T0> template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0...)> struct is_unary_function_impl<R (__cdecl*)(T0...)>
{ static const bool value = true; }; { static const bool value = true; };
#endif #endif
// avoid duplicate definitions of is_unary_or_binary_function_impl
#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1)>
{ static const bool value = true; };
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1...)>
{ static const bool value = true; };
#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1)>
{ static const bool value = true; };
#ifndef _MANAGED
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (__fastcall*)(T0, T1)>
{ static const bool value = true; };
#endif
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1)>
{ static const bool value = true; };
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1...)>
{ static const bool value = true; };
#endif
template <typename T> template <typename T>
struct is_unary_or_binary_function_impl<T&> struct is_unary_function_impl<T&>
{ static const bool value = false; }; { static const bool value = false; };
template<typename T> template<typename T>
struct is_unary_or_binary_function struct is_unary_function
{ static const bool value = is_unary_or_binary_function_impl<T>::value; }; { static const bool value = is_unary_function_impl<T>::value; };
} //namespace move_detail { } //namespace move_detail {
} //namespace boost { } //namespace boost {

4
include/boost/move/detail/workaround.hpp
View File

@@ -20,6 +20,10 @@
//Macros for documentation purposes. For code, expands to the argument //Macros for documentation purposes. For code, expands to the argument
#define BOOST_MOVE_IMPDEF(TYPE) TYPE #define BOOST_MOVE_IMPDEF(TYPE) TYPE
#define BOOST_MOVE_SEEDOC(TYPE) TYPE #define BOOST_MOVE_SEEDOC(TYPE) TYPE
#define BOOST_MOVE_DOC0PTR(TYPE) TYPE
#define BOOST_MOVE_DOC1ST(TYPE1, TYPE2) TYPE2
#define BOOST_MOVE_I ,
#define BOOST_MOVE_DOCIGN(T1) T1
#include <boost/intrusive/detail/config_end.hpp> #include <boost/intrusive/detail/config_end.hpp>

900
include/boost/move/unique_ptr.hpp
View File

File diff suppressed because it is too large Load Diff

144
test/unique_ptr.cpp
View File

@@ -10,8 +10,6 @@
// See http://www.boost.org/libs/move for documentation. // See http://www.boost.org/libs/move for documentation.
// //
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#include <boost/move/detail/config_begin.hpp>
#include <boost/move/utility_core.hpp> #include <boost/move/utility_core.hpp>
#include <boost/move/unique_ptr.hpp> #include <boost/move/unique_ptr.hpp>
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
@@ -511,17 +509,22 @@ void test()
} //unique_ptr_asgn_move01 } //unique_ptr_asgn_move01
//////////////////////////////// ////////////////////////////////
// unique_ptr_asgn_null // unique_ptr_zero
//////////////////////////////// ////////////////////////////////
namespace unique_ptr_asgn_null { namespace unique_ptr_zero {
// test assignment from null // test initialization/assignment from zero
void test() void test()
{ {
//Single unique_ptr //Single unique_ptr
reset_counters(); reset_counters();
{ {
bml::unique_ptr<A> s2(0);
BOOST_TEST(A::count == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A> s2(new A); bml::unique_ptr<A> s2(new A);
BOOST_TEST(A::count == 1); BOOST_TEST(A::count == 1);
s2 = 0; s2 = 0;
@@ -532,6 +535,11 @@ void test()
//Array unique_ptr //Array unique_ptr
{ {
bml::unique_ptr<A[]> s2(0);
BOOST_TEST(A::count == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A[]> s2(new A[2]); bml::unique_ptr<A[]> s2(new A[2]);
BOOST_TEST(A::count == 2); BOOST_TEST(A::count == 2);
s2 = 0; s2 = 0;
@@ -541,8 +549,7 @@ void test()
BOOST_TEST(A::count == 0); BOOST_TEST(A::count == 0);
} }
} //namespace unique_ptr_zero {
} //namespace unique_ptr_asgn_null {
//////////////////////////////// ////////////////////////////////
@@ -1476,7 +1483,7 @@ void test()
{ {
//Single unique_ptr //Single unique_ptr
reset_counters(); reset_counters();
{ { //reset()
bml::unique_ptr<A> p(new A); bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1); BOOST_TEST(A::count == 1);
A* i = p.get(); A* i = p.get();
@@ -1486,7 +1493,7 @@ void test()
BOOST_TEST(p.get() == 0); BOOST_TEST(p.get() == 0);
} }
BOOST_TEST(A::count == 0); BOOST_TEST(A::count == 0);
{ { //reset(p)
bml::unique_ptr<A> p(new A); bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1); BOOST_TEST(A::count == 1);
A* i = p.get(); A* i = p.get();
@@ -1495,9 +1502,19 @@ void test()
BOOST_TEST(A::count == 1); BOOST_TEST(A::count == 1);
} }
BOOST_TEST(A::count == 0); BOOST_TEST(A::count == 0);
{ //reset(0)
bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1);
A* i = p.get();
(void)i;
p.reset(0);
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
//Array unique_ptr //Array unique_ptr
reset_counters(); reset_counters();
{ { //reset()
bml::unique_ptr<A[]> p(new A[2]); bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2); BOOST_TEST(A::count == 2);
A* i = p.get(); A* i = p.get();
@@ -1507,7 +1524,7 @@ void test()
BOOST_TEST(p.get() == 0); BOOST_TEST(p.get() == 0);
} }
BOOST_TEST(A::count == 0); BOOST_TEST(A::count == 0);
{ { //reset(p)
bml::unique_ptr<A[]> p(new A[2]); bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2); BOOST_TEST(A::count == 2);
A* i = p.get(); A* i = p.get();
@@ -1516,6 +1533,16 @@ void test()
BOOST_TEST(A::count == 3); BOOST_TEST(A::count == 3);
} }
BOOST_TEST(A::count == 0); BOOST_TEST(A::count == 0);
{ //reset(0)
bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2);
A* i = p.get();
(void)i;
p.reset(0);
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
} }
} //namespace unique_ptr_modifiers_reset1{ } //namespace unique_ptr_modifiers_reset1{
@@ -1820,6 +1847,92 @@ void test()
} //namespace unique_ptr_observers_op_index{ } //namespace unique_ptr_observers_op_index{
////////////////////////////////
// unique_ptr_nullptr
////////////////////////////////
namespace unique_ptr_nullptr{
void test()
{
#if !defined(BOOST_NO_CXX11_NULLPTR)
//Single unique_ptr
reset_counters();
{
bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1);
A* i = p.get();
(void)i;
p.reset(nullptr);
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1);
A* i = p.get();
(void)i;
p = nullptr;
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A> pi(nullptr);
BOOST_TEST(pi.get() == nullptr);
BOOST_TEST(pi.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A> pi(nullptr, bml::unique_ptr<A>::deleter_type());
BOOST_TEST(pi.get() == nullptr);
BOOST_TEST(pi.get() == 0);
}
BOOST_TEST(A::count == 0);
//Array unique_ptr
reset_counters();
{
bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2);
A* i = p.get();
(void)i;
p.reset(nullptr);
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2);
A* i = p.get();
(void)i;
p = nullptr;
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A[]> pi(nullptr);
BOOST_TEST(pi.get() == nullptr);
BOOST_TEST(pi.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A[]> pi(nullptr, bml::unique_ptr<A[]>::deleter_type());
BOOST_TEST(pi.get() == nullptr);
BOOST_TEST(pi.get() == 0);
}
BOOST_TEST(A::count == 0);
//Array element
#endif
}
} //namespace unique_ptr_nullptr{
//////////////////////////////// ////////////////////////////////
// main // main
//////////////////////////////// ////////////////////////////////
@@ -1833,7 +1946,6 @@ int main()
unique_ptr_asgn_move_convert02::test(); unique_ptr_asgn_move_convert02::test();
unique_ptr_asgn_move_convert03::test(); unique_ptr_asgn_move_convert03::test();
unique_ptr_asgn_move01::test(); unique_ptr_asgn_move01::test();
unique_ptr_asgn_null::test();
//Constructor //Constructor
unique_ptr_ctor_default01::test(); unique_ptr_ctor_default01::test();
@@ -1873,8 +1985,13 @@ int main()
unique_ptr_observers_op_arrow::test(); unique_ptr_observers_op_arrow::test();
unique_ptr_observers_op_index::test(); unique_ptr_observers_op_index::test();
//nullptr
unique_ptr_zero::test();
unique_ptr_nullptr::test();
//Test results //Test results
return boost::report_errors(); return boost::report_errors();
} }
//Define the incomplete I type and out of line functions //Define the incomplete I type and out of line functions
@@ -1902,6 +2019,3 @@ J<T, D>::~J() {}
void reset_counters() void reset_counters()
{ A::count = 0; B::count = 0; I::count = 0; } { A::count = 0; B::count = 0; I::count = 0; }
#include <boost/move/detail/config_end.hpp>

4
test/unique_ptr_default_deleter.cpp
View File

@@ -10,8 +10,6 @@
// See http://www.boost.org/libs/move for documentation. // See http://www.boost.org/libs/move for documentation.
// //
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#include <boost/move/detail/config_begin.hpp>
#include <boost/move/unique_ptr.hpp> #include <boost/move/unique_ptr.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
@@ -130,5 +128,3 @@ int main()
//Test results //Test results
return boost::report_errors(); return boost::report_errors();
} }
#include <boost/move/detail/config_end.hpp>

121
test/unique_ptr_functions.cpp
View File

@@ -9,7 +9,6 @@
// See http://www.boost.org/libs/move for documentation. // See http://www.boost.org/libs/move for documentation.
// //
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#include <boost/move/detail/config_begin.hpp>
#include <boost/move/make_unique.hpp> #include <boost/move/make_unique.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
@@ -135,30 +134,135 @@ void test()
//Equal //Equal
BOOST_TEST(rpl == rpl && rpl.get() == rpl.get()); BOOST_TEST(rpl == rpl && rpl.get() == rpl.get());
BOOST_TEST(!(rpl == rpg) && !(rpl.get() != rpg.get())); BOOST_TEST(!(rpl == rpg) && !(rpl.get() == rpg.get()));
//Unequal //Unequal
BOOST_TEST(rpl != rpg && rpl.get() != rpg.get()); BOOST_TEST(rpl != rpg && rpl.get() != rpg.get());
BOOST_TEST(!(rpl != rpl) && !(rpl.get() != rpl.get())); BOOST_TEST(!(rpl != rpl) && !(rpl.get() != rpl.get()));
//Less //Less
BOOST_TEST(rpl < rpg && rpl.get() < rpg.get()); BOOST_TEST(rpl < rpg && rpl.get() < rpg.get());
BOOST_TEST(!(rpl < rpg) && !(rpl.get() < rpg.get())); BOOST_TEST(!(rpg < rpl) && !(rpg.get() < rpl.get()));
//Greater //Greater
BOOST_TEST(rpg > rpl && rpg.get() > rpl.get()); BOOST_TEST(rpg > rpl && rpg.get() > rpl.get());
BOOST_TEST(!(rpg > rpg) && !(rpg.get() > rpl.get())); BOOST_TEST(!(rpg > rpg) && !(rpg.get() > rpg.get()));
//Less or equal //Less or equal
BOOST_TEST(rpl <= rpg && rpl.get() <= rpg.get()); BOOST_TEST(rpl <= rpg && rpl.get() <= rpg.get());
BOOST_TEST(rpl <= rpl && rpl.get() <= rpl.get()); BOOST_TEST(rpl <= rpl && rpl.get() <= rpl.get());
BOOST_TEST(!(rpg <= rpl) && !(rpg.get() < rpl.get())); BOOST_TEST(!(rpg <= rpl) && !(rpg.get() <= rpl.get()));
//Greater or equal //Greater or equal
BOOST_TEST(rpg >= rpl && rpg.get() >= rpl.get()); BOOST_TEST(rpg >= rpl && rpg.get() >= rpl.get());
BOOST_TEST(rpg >= rpg && rpg.get() >= rpg.get()); BOOST_TEST(rpg >= rpg && rpg.get() >= rpg.get());
BOOST_TEST(!(rpl >= rpg) && !(rpl.get() < rpg.get())); BOOST_TEST(!(rpl >= rpg) && !(rpl.get() >= rpg.get()));
} }
BOOST_TEST(A::count == 0); BOOST_TEST(A::count == 0);
} }
} //namespace unique_compare{ } //namespace unique_compare{
////////////////////////////////
// unique_compare_zero
////////////////////////////////
namespace unique_compare_zero{
void test()
{
//Single element deleter
reset_counters();
{
bml::unique_ptr<A> pa(bml::make_unique<A>());
bml::unique_ptr<A> pb;
BOOST_TEST(A::count == 1);
//Equal
BOOST_TEST(!(pa == 0));
BOOST_TEST(!(0 == pa));
BOOST_TEST((pb == 0));
BOOST_TEST((0 == pb));
//Unequal
BOOST_TEST((pa != 0));
BOOST_TEST((0 != pa));
BOOST_TEST(!(pb != 0));
BOOST_TEST(!(0 != pb));
//Less
BOOST_TEST((pa < 0) == (pa.get() < 0));
BOOST_TEST((0 < pa) == (0 < pa.get()));
BOOST_TEST((pb < 0) == (pb.get() < 0));
BOOST_TEST((0 < pb) == (0 < pb.get()));
//Greater
BOOST_TEST((pa > 0) == (pa.get() > 0));
BOOST_TEST((0 > pa) == (0 > pa.get()));
BOOST_TEST((pb > 0) == (pb.get() > 0));
BOOST_TEST((0 > pb) == (0 > pb.get()));
//Less or equal
BOOST_TEST((pa <= 0) == (pa.get() <= 0));
BOOST_TEST((0 <= pa) == (0 <= pa.get()));
BOOST_TEST((pb <= 0) == (pb.get() <= 0));
BOOST_TEST((0 <= pb) == (0 <= pb.get()));
//Greater or equal
BOOST_TEST((pa >= 0) == (pa.get() >= 0));
BOOST_TEST((0 >= pa) == (0 >= pa.get()));
BOOST_TEST((pb >= 0) == (pb.get() >= 0));
BOOST_TEST((0 >= pb) == (0 >= pb.get()));
}
BOOST_TEST(A::count == 0);
}
} //namespace unique_compare_zero{
////////////////////////////////
// unique_compare_nullptr
////////////////////////////////
namespace unique_compare_nullptr{
void test()
{
#if !defined(BOOST_NO_CXX11_NULLPTR)
//Single element deleter
reset_counters();
{
bml::unique_ptr<A> pa(bml::make_unique<A>());
bml::unique_ptr<A> pb;
BOOST_TEST(A::count == 1);
//Equal
BOOST_TEST(!(pa == nullptr));
BOOST_TEST(!(nullptr == pa));
BOOST_TEST((pb == nullptr));
BOOST_TEST((nullptr == pb));
//Unequal
BOOST_TEST((pa != nullptr));
BOOST_TEST((nullptr != pa));
BOOST_TEST(!(pb != nullptr));
BOOST_TEST(!(nullptr != pb));
//Less
BOOST_TEST((pa < nullptr) == (pa.get() < nullptr));
BOOST_TEST((nullptr < pa) == (nullptr < pa.get()));
BOOST_TEST((pb < nullptr) == (pb.get() < nullptr));
BOOST_TEST((nullptr < pb) == (nullptr < pb.get()));
//Greater
BOOST_TEST((pa > nullptr) == (pa.get() > nullptr));
BOOST_TEST((nullptr > pa) == (nullptr > pa.get()));
BOOST_TEST((pb > nullptr) == (pb.get() > nullptr));
BOOST_TEST((nullptr > pb) == (nullptr > pb.get()));
//Less or equal
BOOST_TEST((pa <= nullptr) == (pa.get() <= nullptr));
BOOST_TEST((nullptr <= pa) == (nullptr <= pa.get()));
BOOST_TEST((pb <= nullptr) == (pb.get() <= nullptr));
BOOST_TEST((nullptr <= pb) == (nullptr <= pb.get()));
//Greater or equal
BOOST_TEST((pa >= nullptr) == (pa.get() >= nullptr));
BOOST_TEST((nullptr >= pa) == (nullptr >= pa.get()));
BOOST_TEST((pb >= nullptr) == (pb.get() >= nullptr));
BOOST_TEST((nullptr >= pb) == (nullptr >= pb.get()));
}
BOOST_TEST(A::count == 0);
#endif //#if !defined(BOOST_NO_CXX11_NULLPTR)
}
} //namespace unique_compare_nullptr{
//////////////////////////////// ////////////////////////////////
// main // main
//////////////////////////////// ////////////////////////////////
@@ -166,9 +270,10 @@ int main()
{ {
make_unique_single::test(); make_unique_single::test();
make_unique_array::test(); make_unique_array::test();
unique_compare::test();
unique_compare_zero::test();
unique_compare_nullptr::test();
//Test results //Test results
return boost::report_errors(); return boost::report_errors();
} }
#include <boost/move/detail/config_end.hpp>