Imported Upstream version 17.22.1

[platform/upstream/libzypp.git] / tests / zypp / PtrTypes_test.cc

diff --git a/tests/zypp/PtrTypes_test.cc b/tests/zypp/PtrTypes_test.cc
index 3a6d12e..a5b21dd 100644 (file)
--- a/tests/zypp/PtrTypes_test.cc
+++ b/tests/zypp/PtrTypes_test.cc
@@ -1,6 +1,6 @@
 #include <iostream>
 
-#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/unit_test.hpp>
 
 #include "zypp/base/Logger.h"
 #include <zypp/base/PtrTypes.h>
@@ -17,8 +17,8 @@ using namespace zypp::base;
 #define TRACE_TAG DBG << this->numericId() << " " << __PRETTY_FUNCTION__ << endl
 
 /** Logs Ctor, CopyCtor, Assign and Dtor. */
-template<class _Trace>
-  struct Trace : public ProvideNumericId<_Trace,unsigned>
+template<class TTrace>
+  struct Trace : public ProvideNumericId<TTrace,unsigned>
   {
     Trace()                            { TRACE_TAG; }
     Trace( const Trace & )             { TRACE_TAG; }
@@ -29,14 +29,14 @@ template<class _Trace>
 /** Data class for shared_ptr */
 struct NonIntrusive : private Trace<NonIntrusive>
 {
-  Trace<NonIntrusive>::numericId;
+  using Trace<NonIntrusive>::numericId;
 };
 
 /** Data class for intrusive_ptr */
 struct Intrusive : public ReferenceCounted,
                    private Trace<Intrusive>
 {
-  Trace<Intrusive>::numericId;
+  using Trace<Intrusive>::numericId;
 };
 
 namespace zypp
@@ -54,36 +54,36 @@ namespace zypp
 /******************************************************************
 **
 */
-#define T_NULL       assert( !ptr )
-#define T_NOT_NULL   assert( ptr )
+#define T_NULL       assert( !ptr ); assert( ptr == nullptr )
+#define T_NOT_NULL   assert( ptr ); assert( ptr != nullptr )
 #define T_UNIQUE     assert( ptr.unique() ); assert( ptr.use_count() < 2 )
 #define T_NOT_UNIQUE assert( !ptr.unique() ); assert( ptr.use_count() >= 2 )
 // Also comapre with underlying shared ptr type.
 #define T_EQ(a,b)   assert( a == b ); assert( a == b.cgetPtr() ); assert( a.cgetPtr() == b ); assert( a.cgetPtr() == b.cgetPtr() );
 #define T_NE(a,b)   assert( a != b ); assert( a != b.cgetPtr() ); assert( a.cgetPtr() != b ); assert( a.cgetPtr() != b.cgetPtr() );
 
-template<class _RW>
+template<class RW>
   void test()
   {
     MIL << __PRETTY_FUNCTION__ << std::endl;
     // typedefs that should be provided:
-    typedef typename _RW::_Ptr               _Ptr;
-    typedef typename _RW::_constPtr          _constPtr;
-    typedef typename _Ptr::element_type      _Ptr_element_type;
-    typedef typename _constPtr::element_type _constPtr_element_type;
+    typedef typename RW::PtrType            Ptr;
+    typedef typename RW::constPtrType       constPtr;
+    typedef typename Ptr::element_type      Ptr_element_type;
+    typedef typename constPtr::element_type constPtr_element_type;
     // initial NULL
-    _RW ptr;
+    RW ptr;
     T_NULL;
     T_UNIQUE;
     T_EQ(ptr,ptr);
     // assign
-    ptr = _RW( new _Ptr_element_type );
+    ptr = RW( new Ptr_element_type );
     T_NOT_NULL;
     T_UNIQUE;
     T_EQ(ptr,ptr);
     {
       // share
-      _RW ptr2( ptr );
+      RW ptr2( ptr );
       T_NOT_NULL;
       T_NOT_UNIQUE;
       T_EQ(ptr,ptr2);
@@ -93,26 +93,38 @@ template<class _RW>
       T_UNIQUE;
       T_NE(ptr,ptr2);
       // different impl
-      ptr2.reset( new _Ptr_element_type );
+      ptr2.reset( new Ptr_element_type );
       T_NE(ptr,ptr2);
    }
     // assign
     ptr.reset( 0 );
     T_NULL;
     T_UNIQUE;
+    // nullptr compatible
+    ptr.reset( nullptr );
+    T_NULL;
+    T_UNIQUE;
+    ptr = nullptr;
+    T_NULL;
+    T_UNIQUE;
+    ptr = RW( nullptr );
+    T_NULL;
+    T_UNIQUE;
+
+
   }
 
-template<class _RW>
+template<class RW>
   void cowt()
   {
-    test<_RW>();
+    test<RW>();
     MIL << __PRETTY_FUNCTION__ << std::endl;
-    typedef typename _RW::_Ptr::element_type _Ptr_element_type;
+    typedef typename RW::PtrType::element_type Ptr_element_type;
     // create
-    _RW ptr( new _Ptr_element_type );
+    RW ptr( new Ptr_element_type );
     unsigned long ptrid = ptr->numericId();
     // share
-    _RW ptr2( ptr );
+    RW ptr2( ptr );
     // clone aon access
     unsigned long ptrid2 = ptr2->numericId();
     assert( ptrid != ptrid2 );