loki-lib-cvs

[Loki-lib-cvs] SF.net SVN: loki-lib:[986] trunk/test/SmartPtr/main.cpp

[<ric...@us...>]

Revision: 986
          http://loki-lib.svn.sourceforge.net/loki-lib/?rev=986&view=rev
Author:   rich_sposato
Date:     2009-02-17 05:25:13 +0000 (Tue, 17 Feb 2009)

Log Message:
-----------
Added code to demonstrate how SmartPtr preserves constness through type-safety.

Modified Paths:
--------------
    trunk/test/SmartPtr/main.cpp

Modified: trunk/test/SmartPtr/main.cpp
===================================================================
--- trunk/test/SmartPtr/main.cpp	2009-02-02 07:45:50 UTC (rev 985)
+++ trunk/test/SmartPtr/main.cpp	2009-02-17 05:25:13 UTC (rev 986)
@@ -101,6 +101,10 @@
     AssertCheck, DefaultSPStorage, DontPropagateConst >
     NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr;
 
+typedef Loki::SmartPtr< const BaseClass, DestructiveCopy, DisallowConversion,
+    AssertCheck, DefaultSPStorage, DontPropagateConst >
+    ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr;
+
 typedef Loki::SmartPtr< BaseClass, NoCopy, DisallowConversion,
     AssertCheck, DefaultSPStorage, DontPropagateConst >
     NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr;
@@ -213,6 +217,21 @@
 //  NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p41( p4 );
 //  NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p42( p5 );
 
+    // These constructions are legal because the preserve const-ness.
+    ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p43( p5 );
+    ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p44( p43 );
+    const BaseClass * rawP = new BaseClass;
+    // These constructions are illegal because the don't preserve constness.
+//    NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p45( rawP );
+//    NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p46( p43 );
+    ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p47( rawP );
+
+    NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p48;
+    // This assignment is legal because it preserves constness.
+    p48 = p5;
+    // This assignment is illegal because it won't preserve constness.
+//    p48 = p43;
+
     // illegal assignements!  Can't convert from one ownership policy to another.
 //  p1 = p2;
 //  p1 = p3;


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Loki-lib-cvs] SF.net SVN: loki-lib:[1014] trunk/test/SmartPtr/main.cpp

[<ric...@us...>]

Revision: 1014
          http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1014&view=rev
Author:   rich_sposato
Date:     2009-04-11 06:02:59 +0000 (Sat, 11 Apr 2009)

Log Message:
-----------
Added tests for comparison operators for SmartPtr.

Modified Paths:
--------------
    trunk/test/SmartPtr/main.cpp

Modified: trunk/test/SmartPtr/main.cpp
===================================================================
--- trunk/test/SmartPtr/main.cpp	2009-04-11 06:01:06 UTC (rev 1013)
+++ trunk/test/SmartPtr/main.cpp	2009-04-11 06:02:59 UTC (rev 1014)
@@ -373,6 +373,102 @@
     NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p5;
     NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p6( new BaseClass );
 
+    BaseClass * pBare1 = GetImpl( p1 );
+    BaseClass * pBare2 = GetImpl( p2 );
+    BaseClass * pBare6 = GetImpl( p6 );
+    const bool is1LessThan2 = ( pBare1 < pBare2 );
+    const bool is1LessThan6 = ( pBare1 < pBare6 );
+    const bool is2LessThan6 = ( pBare2 < pBare6 );
+    assert( pBare1 != pBare2 );
+    assert( pBare1 != pBare6 );
+    assert( pBare2 != pBare6 );
+    assert( p1 == pBare1 );
+    assert( p2 == pBare2 );
+    assert( p6 == pBare6 );
+    assert( pBare1 == p1 );
+    assert( pBare2 == p2 );
+    assert( pBare6 == p6 );
+    assert( pBare2 != p1 );
+    assert( p1 != pBare2 );
+
+    if ( is1LessThan2 )
+    {
+        assert( p1 < p2 );
+        assert( p1 <= p2 );
+        assert( p1 != p2 );
+        assert( p2 > p1 );
+        assert( p2 >= p1 );
+        assert( p1 < pBare2 );
+        assert( p1 <= pBare2 );
+        assert( pBare2 > p1 );
+        assert( pBare2 >= p1 );
+    }
+    else
+    {
+        assert( p2 < p1 );
+        assert( p2 <= p1 );
+        assert( p2 != p1 );
+        assert( p1 > p2 );
+        assert( p1 >= p2 );
+        assert( p2 < pBare1 );
+        assert( p2 <= pBare1 );
+        assert( p2 != pBare1 );
+        assert( pBare1 > p2 );
+        assert( pBare1 >= p2 );
+    }
+
+    if ( is1LessThan6 )
+    {
+        assert( p1 < p6 );
+        assert( p1 <= p6 );
+        assert( p1 != p6 );
+        assert( p6 > p1 );
+        assert( p6 >= p1 );
+        assert( p1 < pBare6 );
+        assert( p1 <= pBare6 );
+        assert( pBare6 > p1 );
+        assert( pBare6 >= p1 );
+    }
+    else
+    {
+        assert( p6 < p1 );
+        assert( p6 <= p1 );
+        assert( p6 != p1 );
+        assert( p1 > p6 );
+        assert( p1 >= p6 );
+        assert( p6 < pBare1 );
+        assert( p6 <= pBare1 );
+        assert( p6 != pBare1 );
+        assert( pBare1 > p6 );
+        assert( pBare1 >= p6 );
+    }
+
+    if ( is2LessThan6 )
+    {
+        assert( p2 < p6 );
+        assert( p2 <= p6 );
+        assert( p2 != p6 );
+        assert( p6 > p2 );
+        assert( p6 >= p2 );
+        assert( p2 < pBare6 );
+        assert( p2 <= pBare6 );
+        assert( pBare6 > p2 );
+        assert( pBare6 >= p2 );
+    }
+    else
+    {
+        assert( p6 < p2 );
+        assert( p6 <= p2 );
+        assert( p6 != p2 );
+        assert( p2 > p6 );
+        assert( p2 >= p6 );
+        assert( p6 < pBare2 );
+        assert( p6 <= pBare2 );
+        assert( p6 != pBare2 );
+        assert( pBare2 > p6 );
+        assert( pBare2 >= p6 );
+    }
+
     // p1 <---> p3    and    p2 <---> p4   and   p5   and   p6
     assert( p1 == p3 );
     assert( p1 != p2 );


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Loki-lib-cvs] SF.net SVN: loki-lib:[1095] trunk/test/SmartPtr/main.cpp

[<ric...@us...>]

Revision: 1095
          http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1095&view=rev
Author:   rich_sposato
Date:     2011-09-07 22:50:38 +0000 (Wed, 07 Sep 2011)
Log Message:
-----------
Added tests for bug 3224518.

Modified Paths:
--------------
    trunk/test/SmartPtr/main.cpp

Modified: trunk/test/SmartPtr/main.cpp
===================================================================
--- trunk/test/SmartPtr/main.cpp	2011-09-07 22:46:37 UTC (rev 1094)
+++ trunk/test/SmartPtr/main.cpp	2011-09-07 22:50:38 UTC (rev 1095)
@@ -54,7 +54,7 @@
 class Thingy;
 
 typedef Loki::SmartPtr< Thingy, RefCounted, DisallowConversion,
-    AssertCheck, DefaultSPStorage, PropagateConst >
+    NoCheck, DefaultSPStorage, PropagateConst >
     Thingy_DefaultStorage_ptr;
 
 typedef Loki::SmartPtr< Thingy, RefCounted, DisallowConversion,
@@ -69,18 +69,23 @@
     AssertCheck, DefaultSPStorage, DontPropagateConst >
     NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr;
 
-/// @note These 3 are used for testing const policies.
+/// @note These 4 are used for testing const policies.
+
+typedef Loki::SmartPtr< BaseClass, RefCounted, DisallowConversion,
+    NoCheck, DefaultSPStorage, DontPropagateConst >
+    NonConstBase_RefCount_NoConvert_NoCheck_DontPropagate_ptr;
+
 typedef Loki::SmartPtr< const BaseClass, RefCounted, DisallowConversion,
-    AssertCheck, DefaultSPStorage, DontPropagateConst >
-    ConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr;
+    NoCheck, DefaultSPStorage, DontPropagateConst >
+    ConstBase_RefCount_NoConvert_NoCheck_DontPropagate_ptr;
 
 typedef Loki::SmartPtr< const BaseClass, RefCounted, DisallowConversion,
-    AssertCheck, DefaultSPStorage, PropagateConst >
-    ConstBase_RefCount_NoConvert_Assert_Propagate_ptr;
+    NoCheck, DefaultSPStorage, PropagateConst >
+    ConstBase_RefCount_NoConvert_NoCheck_Propagate_ptr;
 
 typedef Loki::SmartPtr< BaseClass, RefCounted, DisallowConversion,
-    AssertCheck, DefaultSPStorage, PropagateConst >
-    NonConstBase_RefCount_NoConvert_Assert_Propagate_ptr;
+    NoCheck, DefaultSPStorage, PropagateConst >
+    NonConstBase_RefCount_NoConvert_NoCheck_Propagate_ptr;
 
 
 // ----------------------------------------------------------------------------
@@ -135,11 +140,12 @@
 
 void DoConstConversionTests( void )
 {
+    cout << "Starting DoConstConversionTests." << endl;
 
-    NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1;
-    ConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p2( p1 );
-    ConstBase_RefCount_NoConvert_Assert_Propagate_ptr p3( p1 );
-    NonConstBase_RefCount_NoConvert_Assert_Propagate_ptr p4( p1 );
+    NonConstBase_RefCount_NoConvert_NoCheck_DontPropagate_ptr p1;
+    ConstBase_RefCount_NoConvert_NoCheck_DontPropagate_ptr p2( p1 );
+    ConstBase_RefCount_NoConvert_NoCheck_Propagate_ptr p3( p1 );
+    NonConstBase_RefCount_NoConvert_NoCheck_Propagate_ptr p4( p1 );
 
 //  p1 = p2;  // illegal! converts const to non-const.
 //  p1 = p3;  // illegal! converts const to non-const.
@@ -153,775 +159,824 @@
     p4 = p1;  // legal, but dubious. Changes const-propagation policy.
 //  p4 = p2;  // illegal! converts const to non-const.
 //  p4 = p3;  // illegal! converts const to non-const.
+
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoConstConversionTests." << endl;
 }
 
 // ----------------------------------------------------------------------------
 
 void DoOwnershipConversionTests( void )
 {
-    NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1;
-    NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p2;
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p3;
-    NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p4( new BaseClass );
-    NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p5;
-    NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p6;
+    cout << "Starting DoOwnershipConversionTests." << endl;
 
-    // legal constructions.  Each should allow copy with same policies.
-    NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p7( p1 );
-    NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p8( p2 );
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p9( p3 );
-    NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p10( p4 );
-    NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p11( p5 );
+    {
+        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1( new BaseClass );
+        NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p2( new BaseClass );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p3( new BaseClass );
+        NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p4( new BaseClass );
+        NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p5( new BaseClass );
+        NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p6( new BaseClass );
 
-    // illegal construction!  Can't copy anything with NoCopy policy.
-    // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p12( p6 );
+        // legal constructions.  Each should allow copy with same policies.
+        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p7( p1 );
+        NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p8( p2 );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p9( p3 );
+        NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p10( p4 );
+        NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p11( p5 );
 
-    // illegal constructions!  Can't convert from one ownership policy to another.
-//  NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p13( p2 );
-//  NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p14( p3 );
-//  NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p15( p4 );
-//  NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p16( p5 );
-//  NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p17( p6 );
+        // illegal construction!  Can't copy anything with NoCopy policy.
+        // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p12( p6 );
 
-    // illegal constructions!  Can't convert from one ownership policy to another.
-//  NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p18( p1 );
-//  NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p19( p3 );
-//  NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p20( p4 );
-//  NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p21( p5 );
-//  NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p22( p6 );
+        // illegal constructions!  Can't convert from one ownership policy to another.
+        // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p13( p2 );
+        // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p14( p3 );
+        // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p15( p4 );
+        // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p16( p5 );
+        // NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p17( p6 );
 
-    // illegal constructions!  Can't convert from one ownership policy to another.
-//  NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p23( p1 );
-//  NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p24( p2 );
-//  NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p25( p4 );
-//  NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p26( p5 );
-//  NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p27( p6 );
+        // illegal constructions!  Can't convert from one ownership policy to another.
+        // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p18( p1 );
+        // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p19( p3 );
+        // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p20( p4 );
+        // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p21( p5 );
+        // NonConstBase_ComRef_NoConvert_Assert_DontPropagate_ptr p22( p6 );
 
-    // illegal constructions!  Can't convert from one ownership policy to another.
-//  NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p28( p1 );
-//  NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p29( p2 );
-//  NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p30( p3 );
-//  NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p31( p5 );
-//  NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p32( p6 );
+        // illegal constructions!  Can't convert from one ownership policy to another.
+        // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p23( p1 );
+        // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p24( p2 );
+        // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p25( p4 );
+        // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p26( p5 );
+        // NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p27( p6 );
 
-    // illegal constructions!  Can't convert from one ownership policy to another.
-//  NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p33( p1 );
-//  NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p34( p2 );
-//  NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p35( p3 );
-//  NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p36( p4 );
-//  NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p37( p6 );
+        // illegal constructions!  Can't convert from one ownership policy to another.
+        // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p28( p1 );
+        // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p29( p2 );
+        // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p30( p3 );
+        // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p31( p5 );
+        // NonConstBase_DeepCopy_NoConvert_Assert_DontPropagate_ptr p32( p6 );
 
-    // illegal constructions!  Can't convert from one ownership policy to another.
-//  NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p38( p1 );
-//  NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p39( p2 );
-//  NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p40( p3 );
-//  NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p41( p4 );
-//  NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p42( p5 );
+        // illegal constructions!  Can't convert from one ownership policy to another.
+        // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p33( p1 );
+        // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p34( p2 );
+        // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p35( p3 );
+        // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p36( p4 );
+        // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p37( p6 );
 
-    // These constructions are legal because the preserve const-ness.
-    ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p43( p5 );
-    ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p44( p43 );
-    const BaseClass * rawP = new BaseClass;
-    // These constructions are illegal because the don't preserve constness.
-//    NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p45( rawP );
-//    NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p46( p43 );
-    ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p47( rawP );
+        // illegal constructions!  Can't convert from one ownership policy to another.
+        // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p38( p1 );
+        // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p39( p2 );
+        // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p40( p3 );
+        // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p41( p4 );
+        // NonConstBase_NoCopy_NoConvert_Assert_DontPropagate_ptr p42( p5 );
+    }
 
-    NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p48;
-    // This assignment is legal because it preserves constness.
-    p48 = p5;
-    // This assignment is illegal because it won't preserve constness.
-//    p48 = p43;
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
 
-    // illegal assignements!  Can't convert from one ownership policy to another.
-//  p1 = p2;
-//  p1 = p3;
-//  p1 = p4;
-//  p1 = p5;
-//  p1 = p6;
-//  p2 = p1;
-//  p2 = p3;
-//  p2 = p4;
-//  p2 = p5;
-//  p2 = p6;
-//  p3 = p1;
-//  p3 = p2;
-//  p3 = p4;
-//  p3 = p5;
-//  p3 = p6;
-//  p4 = p1;
-//  p4 = p2;
-//  p4 = p3;
-//  p4 = p5;
-//  p4 = p6;
-//  p5 = p1;
-//  p5 = p2;
-//  p5 = p3;
-//  p5 = p4;
-//  p5 = p6;
-//  p6 = p1;
-//  p6 = p2;
-//  p6 = p3;
-//  p6 = p4;
-//  p6 = p5;
+    {
+        // These constructions are legal because the preserve const-ness.
+        const BaseClass * rawP = new BaseClass;
+        ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p43( rawP );
+        ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p44( p43 );
+        rawP = new BaseClass;
+        // These constructions are illegal because the don't preserve constness.
+        // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p45( rawP );
+        // NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p46( p43 );
+        ConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p47( rawP );
+
+        NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p48;
+        NonConstBase_KillCopy_NoConvert_Assert_DontPropagate_ptr p49( new BaseClass );
+        // This assignment is legal because it preserves constness.
+        p48 = p49;
+        // This assignment is illegal because it won't preserve constness.
+        // p48 = p43;
+
+        // illegal assignments!  Can't convert from one ownership policy to another.
+        // p1 = p2;
+        // p1 = p3;
+        // p1 = p4;
+        // p1 = p5;
+        // p1 = p6;
+        // p2 = p1;
+        // p2 = p3;
+        // p2 = p4;
+        // p2 = p5;
+        // p2 = p6;
+        // p3 = p1;
+        // p3 = p2;
+        // p3 = p4;
+        // p3 = p5;
+        // p3 = p6;
+        // p4 = p1;
+        // p4 = p2;
+        // p4 = p3;
+        // p4 = p5;
+        // p4 = p6;
+        // p5 = p1;
+        // p5 = p2;
+        // p5 = p3;
+        // p5 = p4;
+        // p5 = p6;
+        // p6 = p1;
+        // p6 = p2;
+        // p6 = p3;
+        // p6 = p4;
+        // p6 = p5;
+    }
+
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoOwnershipConversionTests." << endl;
 }
 
 // ----------------------------------------------------------------------------
 
 void DoInheritanceConversionTests( void )
 {
-    NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1;
-    PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr p2;
-    PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr p3;
+    cout << "Starting DoInheritanceConversionTests." << endl;
 
-    p1 = p2;  // legal.  Cast to public base class allowed.
-    assert( p1 == p2 );
-//  p1 = p3;  // illegal!  Can't assign pointer since base class is private.
-//  p2 = p1;  // illegal!  Can't do cast to derived class in pointer assignment.
-//  p2 = p3;  // illegal!  Can't assign when types are unrelated.
-//  p3 = p1;  // illegal!  Can't do cast to derived class in pointer assignment.
-//  p3 = p2;  // illegal!  Can't assign when types are unrelated.
+    {
+        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1;
+        PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr p2( new PublicSubClass );
+        PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr p3;
 
-    NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p4( p2 );
-    assert( p4 == p1 );
-    assert( p4 == p2 );
-    // These copy-constructions are illegal for reasons shown above.
-//  NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p5( p3 );
-//  PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr p6( p1 );
-//  PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr p7( p3 );
-//  PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr p8( p1 );
-//  PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr p9( p2 );
+        p1 = p2;  // legal.  Cast to public base class allowed.
+        assert( p1 == p2 );
+//      p1 = p3;  // illegal!  Can't assign pointer since base class is private.
+//      p2 = p1;  // illegal!  Can't do cast to derived class in pointer assignment.
+//      p2 = p3;  // illegal!  Can't assign when types are unrelated.
+//      p3 = p1;  // illegal!  Can't do cast to derived class in pointer assignment.
+//      p3 = p2;  // illegal!  Can't assign when types are unrelated.
+
+        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p4( p2 );
+        assert( p4 == p1 );
+        assert( p4 == p2 );
+        // These copy-constructions are illegal for reasons shown above.
+//      NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p5( p3 );
+//      PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr p6( p1 );
+//      PublicSub_RefCount_NoConvert_Assert_DontPropagate_ptr p7( p3 );
+//      PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr p8( p1 );
+//      PrivateSub_RefCount_NoConvert_Assert_DontPropagate_ptr p9( p2 );
+    }
+
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoInheritanceConversionTests." << endl;
 }
 
 // ----------------------------------------------------------------------------
 
 void DoRefCountSwapTests( void )
 {
-    NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1( new BaseClass );
-    NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p2( new BaseClass );
+    cout << "Starting DoRefCountSwapTests." << endl;
 
-    NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p3( p1 );
-    NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p4( p2 );
+    {
+        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1( new BaseClass );
+        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p2( new BaseClass );
 
-    // p1 == p3    and    p2 == p4
-    assert( p1 == p3 );
-    assert( p1 != p2 );
-    assert( p1 != p4 );
-    assert( p2 == p4 );
-    assert( p2 != p3 );
-    assert( p2 != p1 );
+        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p3( p1 );
+        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p4( p2 );
 
-    // p1 == p4    and    p2 == p3
-    p3.Swap( p4 );
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
+        // p1 == p3    and    p2 == p4
+        assert( p1 == p3 );
+        assert( p1 != p2 );
+        assert( p1 != p4 );
+        assert( p2 == p4 );
+        assert( p2 != p3 );
+        assert( p2 != p1 );
 
-    // p1 == p3    and    p2 == p4
-    p3.Swap( p4 );
-    assert( p1 == p3 );
-    assert( p1 != p2 );
-    assert( p1 != p4 );
-    assert( p2 == p4 );
-    assert( p2 != p3 );
-    assert( p2 != p1 );
+        // p1 == p4    and    p2 == p3
+        p3.Swap( p4 );
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
 
-    // p2 == p3    and    p1 == p4
-    p1.Swap( p2 );
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
+        // p1 == p3    and    p2 == p4
+        p3.Swap( p4 );
+        assert( p1 == p3 );
+        assert( p1 != p2 );
+        assert( p1 != p4 );
+        assert( p2 == p4 );
+        assert( p2 != p3 );
+        assert( p2 != p1 );
 
-    // p2 == p3    and    p1 == p4
-    p1.Swap( p1 );
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
+        // p2 == p3    and    p1 == p4
+        p1.Swap( p2 );
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
 
-    // p2 == p3    and    p4 == p1
-    p1.Swap( p4 );
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
+        // p2 == p3    and    p1 == p4
+        p1.Swap( p1 );
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
+
+        // p2 == p3    and    p4 == p1
+        p1.Swap( p4 );
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
+    }
+
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoRefCountSwapTests." << endl;
 }
 
 // ----------------------------------------------------------------------------
 
 void DoRefLinkSwapTests( void )
 {
+    cout << "Starting DoRefLinkSwapTests." << endl;
 
-    BaseClass * pBaseClass = new BaseClass;
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p1( pBaseClass );
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p2( new BaseClass );
-    p1->DoThat();
-    p2->DoThat();
+    {
+        BaseClass * pBaseClass = new BaseClass;
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p1( pBaseClass );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p2( new BaseClass );
+        p1->DoThat();
+        p2->DoThat();
 
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p3( p1 );
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p4( p2 );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p3( p1 );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p4( p2 );
 
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p5;
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p6( new BaseClass );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p5;
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p6( new BaseClass );
 
-    BaseClass * pBare1 = GetImpl( p1 );
-    BaseClass * pBare2 = GetImpl( p2 );
-    BaseClass * pBare6 = GetImpl( p6 );
-    const bool is1LessThan2 = ( pBare1 < pBare2 );
-    const bool is1LessThan6 = ( pBare1 < pBare6 );
-    const bool is2LessThan6 = ( pBare2 < pBare6 );
-    assert( pBare1 != pBare2 );
-    assert( pBare1 != pBare6 );
-    assert( pBare2 != pBare6 );
-    assert( p1 == pBare1 );
-    assert( p2 == pBare2 );
-    assert( p6 == pBare6 );
-    assert( pBare1 == p1 );
-    assert( pBare2 == p2 );
-    assert( pBare6 == p6 );
-    assert( pBare2 != p1 );
-    assert( p1 != pBare2 );
+        BaseClass * pBare1 = GetImpl( p1 );
+        BaseClass * pBare2 = GetImpl( p2 );
+        BaseClass * pBare6 = GetImpl( p6 );
+        const bool is1LessThan2 = ( pBare1 < pBare2 );
+        const bool is1LessThan6 = ( pBare1 < pBare6 );
+        const bool is2LessThan6 = ( pBare2 < pBare6 );
+        assert( pBare1 != pBare2 );
+        assert( pBare1 != pBare6 );
+        assert( pBare2 != pBare6 );
+        assert( p1 == pBare1 );
+        assert( p2 == pBare2 );
+        assert( p6 == pBare6 );
+        assert( pBare1 == p1 );
+        assert( pBare2 == p2 );
+        assert( pBare6 == p6 );
+        assert( pBare2 != p1 );
+        assert( p1 != pBare2 );
 
-    if ( is1LessThan2 )
-    {
-        assert( p1 < p2 );
-        assert( p1 <= p2 );
+        if ( is1LessThan2 )
+        {
+            assert( p1 < p2 );
+            assert( p1 <= p2 );
+            assert( p1 != p2 );
+            assert( p2 > p1 );
+            assert( p2 >= p1 );
+            assert( p1 < pBare2 );
+            assert( p1 <= pBare2 );
+            assert( pBare2 > p1 );
+            assert( pBare2 >= p1 );
+        }
+        else
+        {
+            assert( p2 < p1 );
+            assert( p2 <= p1 );
+            assert( p2 != p1 );
+            assert( p1 > p2 );
+            assert( p1 >= p2 );
+            assert( p2 < pBare1 );
+            assert( p2 <= pBare1 );
+            assert( p2 != pBare1 );
+            assert( pBare1 > p2 );
+            assert( pBare1 >= p2 );
+        }
+
+        if ( is1LessThan6 )
+        {
+            assert( p1 < p6 );
+            assert( p1 <= p6 );
+            assert( p1 != p6 );
+            assert( p6 > p1 );
+            assert( p6 >= p1 );
+            assert( p1 < pBare6 );
+            assert( p1 <= pBare6 );
+            assert( pBare6 > p1 );
+            assert( pBare6 >= p1 );
+        }
+        else
+        {
+            assert( p6 < p1 );
+            assert( p6 <= p1 );
+            assert( p6 != p1 );
+            assert( p1 > p6 );
+            assert( p1 >= p6 );
+            assert( p6 < pBare1 );
+            assert( p6 <= pBare1 );
+            assert( p6 != pBare1 );
+            assert( pBare1 > p6 );
+            assert( pBare1 >= p6 );
+        }
+
+        if ( is2LessThan6 )
+        {
+            assert( p2 < p6 );
+            assert( p2 <= p6 );
+            assert( p2 != p6 );
+            assert( p6 > p2 );
+            assert( p6 >= p2 );
+            assert( p2 < pBare6 );
+            assert( p2 <= pBare6 );
+            assert( pBare6 > p2 );
+            assert( pBare6 >= p2 );
+        }
+        else
+        {
+            assert( p6 < p2 );
+            assert( p6 <= p2 );
+            assert( p6 != p2 );
+            assert( p2 > p6 );
+            assert( p2 >= p6 );
+            assert( p6 < pBare2 );
+            assert( p6 <= pBare2 );
+            assert( p6 != pBare2 );
+            assert( pBare2 > p6 );
+            assert( pBare2 >= p6 );
+        }
+
+        // p1 <---> p3    and    p2 <---> p4   and   p5   and   p6
+        assert( p1 == p3 );
         assert( p1 != p2 );
-        assert( p2 > p1 );
-        assert( p2 >= p1 );
-        assert( p1 < pBare2 );
-        assert( p1 <= pBare2 );
-        assert( pBare2 > p1 );
-        assert( pBare2 >= p1 );
-    }
-    else
-    {
-        assert( p2 < p1 );
-        assert( p2 <= p1 );
+        assert( p1 != p4 );
+        assert( p2 == p4 );
+        assert( p2 != p3 );
         assert( p2 != p1 );
-        assert( p1 > p2 );
-        assert( p1 >= p2 );
-        assert( p2 < pBare1 );
-        assert( p2 <= pBare1 );
-        assert( p2 != pBare1 );
-        assert( pBare1 > p2 );
-        assert( pBare1 >= p2 );
-    }
+        assert( p1 != p5 );
+        assert( p2 != p5 );
+        assert( p3 != p5 );
+        assert( p4 != p5 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
 
-    if ( is1LessThan6 )
-    {
-        assert( p1 < p6 );
-        assert( p1 <= p6 );
-        assert( p1 != p6 );
-        assert( p6 > p1 );
-        assert( p6 >= p1 );
-        assert( p1 < pBare6 );
-        assert( p1 <= pBare6 );
-        assert( pBare6 > p1 );
-        assert( pBare6 >= p1 );
-    }
-    else
-    {
-        assert( p6 < p1 );
-        assert( p6 <= p1 );
-        assert( p6 != p1 );
-        assert( p1 > p6 );
-        assert( p1 >= p6 );
-        assert( p6 < pBare1 );
-        assert( p6 <= pBare1 );
-        assert( p6 != pBare1 );
-        assert( pBare1 > p6 );
-        assert( pBare1 >= p6 );
-    }
+        p3.Swap( p4 );  // p1 <---> p4    and    p2 <---> p3   and   p5   and   p6
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
+        assert( p1 != p5 );
+        assert( p2 != p5 );
+        assert( p3 != p5 );
+        assert( p4 != p5 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
 
-    if ( is2LessThan6 )
-    {
-        assert( p2 < p6 );
-        assert( p2 <= p6 );
-        assert( p2 != p6 );
-        assert( p6 > p2 );
-        assert( p6 >= p2 );
-        assert( p2 < pBare6 );
-        assert( p2 <= pBare6 );
-        assert( pBare6 > p2 );
-        assert( pBare6 >= p2 );
-    }
-    else
-    {
-        assert( p6 < p2 );
-        assert( p6 <= p2 );
-        assert( p6 != p2 );
-        assert( p2 > p6 );
-        assert( p2 >= p6 );
-        assert( p6 < pBare2 );
-        assert( p6 <= pBare2 );
-        assert( p6 != pBare2 );
-        assert( pBare2 > p6 );
-        assert( pBare2 >= p6 );
-    }
+        p3.Swap( p4 );   // p1 <---> p3    and    p2 <---> p4   and   p5   and   p6
+        assert( p1 == p3 );
+        assert( p1 != p2 );
+        assert( p1 != p4 );
+        assert( p2 == p4 );
+        assert( p2 != p3 );
+        assert( p2 != p1 );
+        assert( p1 != p5 );
+        assert( p2 != p5 );
+        assert( p3 != p5 );
+        assert( p4 != p5 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
 
-    // p1 <---> p3    and    p2 <---> p4   and   p5   and   p6
-    assert( p1 == p3 );
-    assert( p1 != p2 );
-    assert( p1 != p4 );
-    assert( p2 == p4 );
-    assert( p2 != p3 );
-    assert( p2 != p1 );
-    assert( p1 != p5 );
-    assert( p2 != p5 );
-    assert( p3 != p5 );
-    assert( p4 != p5 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
+        p1.Swap( p2 );  // p2 <---> p3    and    p1 <---> p4   and   p5   and   p6
+        assert( p1 != pBaseClass );
+        assert( p2 == pBaseClass );
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
+        assert( p1 != p5 );
+        assert( p2 != p5 );
+        assert( p3 != p5 );
+        assert( p4 != p5 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
 
-    p3.Swap( p4 );  // p1 <---> p4    and    p2 <---> p3   and   p5   and   p6
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
-    assert( p1 != p5 );
-    assert( p2 != p5 );
-    assert( p3 != p5 );
-    assert( p4 != p5 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
+        p1.Swap( p1 );  // p2 <---> p3    and    p1 <---> p4   and   p5   and   p6
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
+        assert( p1 != p5 );
+        assert( p2 != p5 );
+        assert( p3 != p5 );
+        assert( p4 != p5 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
 
-    p3.Swap( p4 );   // p1 <---> p3    and    p2 <---> p4   and   p5   and   p6
-    assert( p1 == p3 );
-    assert( p1 != p2 );
-    assert( p1 != p4 );
-    assert( p2 == p4 );
-    assert( p2 != p3 );
-    assert( p2 != p1 );
-    assert( p1 != p5 );
-    assert( p2 != p5 );
-    assert( p3 != p5 );
-    assert( p4 != p5 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
+        p1.Swap( p4 );  // p2 <---> p3    and    p4 <---> p1   and   p5   and   p6
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
+        assert( p1 != p5 );
+        assert( p2 != p5 );
+        assert( p3 != p5 );
+        assert( p4 != p5 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
 
-    p1.Swap( p2 );  // p2 <---> p3    and    p1 <---> p4   and   p5   and   p6
-    assert( p1 != pBaseClass );
-    assert( p2 == pBaseClass );
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
-    assert( p1 != p5 );
-    assert( p2 != p5 );
-    assert( p3 != p5 );
-    assert( p4 != p5 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
+        p4.Swap( p1 );  // p2 <---> p3    and    p4 <---> p1   and   p5   and   p6
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
+        assert( p1 != p5 );
+        assert( p2 != p5 );
+        assert( p3 != p5 );
+        assert( p4 != p5 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
 
-    p1.Swap( p1 );  // p2 <---> p3    and    p1 <---> p4   and   p5   and   p6
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
-    assert( p1 != p5 );
-    assert( p2 != p5 );
-    assert( p3 != p5 );
-    assert( p4 != p5 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
+        p5.Swap( p5 );  // p2 <---> p3    and    p4 <---> p1   and   p5   and   p6
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p1 != p5 );
+        assert( p2 != p5 );
+        assert( p3 != p5 );
+        assert( p4 != p5 );
 
-    p1.Swap( p4 );  // p2 <---> p3    and    p4 <---> p1   and   p5   and   p6
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
-    assert( p1 != p5 );
-    assert( p2 != p5 );
-    assert( p3 != p5 );
-    assert( p4 != p5 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
+        p5.Swap( p1 );  // p2 <---> p3    and    p4 <---> p5   and   p1   and   p6
+        assert( p5 == p4 );
+        assert( p5 != p2 );
+        assert( p5 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p5 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p4 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
 
-    p4.Swap( p1 );  // p2 <---> p3    and    p4 <---> p1   and   p5   and   p6
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
-    assert( p1 != p5 );
-    assert( p2 != p5 );
-    assert( p3 != p5 );
-    assert( p4 != p5 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
+        p6.Swap( p1 );  // p2 <---> p3    and    p4 <---> p5   and   p1   and   p6
+        assert( p5 == p4 );
+        assert( p5 != p2 );
+        assert( p5 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p5 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p4 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
 
-    p5.Swap( p5 );  // p2 <---> p3    and    p4 <---> p1   and   p5   and   p6
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p1 != p5 );
-    assert( p2 != p5 );
-    assert( p3 != p5 );
-    assert( p4 != p5 );
+        p5.Swap( p1 );  // p2 <---> p3    and    p4 <---> p1   and   p5   and   p6
+        assert( p1 == p4 );
+        assert( p1 != p2 );
+        assert( p1 != p3 );
+        assert( p2 == p3 );
+        assert( p2 != p4 );
+        assert( p2 != p1 );
+        assert( p1 != p5 );
+        assert( p2 != p5 );
+        assert( p3 != p5 );
+        assert( p4 != p5 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
 
-    p5.Swap( p1 );  // p2 <---> p3    and    p4 <---> p5   and   p1   and   p6
-    assert( p5 == p4 );
-    assert( p5 != p2 );
-    assert( p5 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p5 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p4 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
+        p6 = p2;  // p6 <---> p2 <---> p3    and    p4 <---> p1   and   p5
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p5 != p3 );
+        assert( p2 != p4 );
+        assert( p2 != p5 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
 
-    p6.Swap( p1 );  // p2 <---> p3    and    p4 <---> p5   and   p1   and   p6
-    assert( p5 == p4 );
-    assert( p5 != p2 );
-    assert( p5 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p5 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p4 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
+        p5 = p3;  // p6 <---> p2 <---> p3 <---> p5   and    p4 <---> p1
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
 
-    p5.Swap( p1 );  // p2 <---> p3    and    p4 <---> p1   and   p5   and   p6
-    assert( p1 == p4 );
-    assert( p1 != p2 );
-    assert( p1 != p3 );
-    assert( p2 == p3 );
-    assert( p2 != p4 );
-    assert( p2 != p1 );
-    assert( p1 != p5 );
-    assert( p2 != p5 );
-    assert( p3 != p5 );
-    assert( p4 != p5 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
+        p5.Swap( p3 );  // p6 <---> p2 <---> p5 <---> p3   and    p4 <---> p1
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
 
-    p6 = p2;  // p6 <---> p2 <---> p3    and    p4 <---> p1   and   p5
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p5 != p3 );
-    assert( p2 != p4 );
-    assert( p2 != p5 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
+        p2.Swap( p3 );  // p6 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
 
-    p5 = p3;  // p6 <---> p2 <---> p3 <---> p5   and    p4 <---> p1
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
+        bool merged = false;
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p7( pBaseClass );
+        assert( p7 == p7 );
+        assert( p6 == p7 );
+        assert( p1 != p7 );
+        merged = p7.Merge( p6 );
+        // p7 <---> p6 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
+        assert( merged );
+        assert( p6 == p7 );
+        assert( p1 != p7 );
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
+        assert( p7 == p7 );
 
-    p5.Swap( p3 );  // p6 <---> p2 <---> p5 <---> p3   and    p4 <---> p1
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p8( pBaseClass );
+        assert( p6 == p8 );
+        assert( p1 != p8 );
+        merged = p6.Merge( p8 );
+        // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
+        assert( merged );
+        assert( p6 == p8 );
+        assert( p6 == p7 );
+        assert( p1 != p7 );
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
+        assert( p7 == p7 );
+        assert( p8 == p8 );
 
-    p2.Swap( p3 );  // p6 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
+        merged = p6.Merge( p6 );
+        // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
+        assert( merged );
+        assert( p6 == p8 );
+        assert( p6 == p7 );
+        assert( p1 != p7 );
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
+        assert( p7 == p7 );
+        assert( p8 == p8 );
 
-    bool merged = false;
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p7( pBaseClass );
-    assert( p7 == p7 );
-    assert( p6 == p7 );
-    assert( p1 != p7 );
-    merged = p7.Merge( p6 );
-    // p7 <---> p6 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
-    assert( merged );
-    assert( p6 == p7 );
-    assert( p1 != p7 );
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
-    assert( p7 == p7 );
+        merged = p6.Merge( p3 );
+        // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
+        assert( merged );
+        assert( p6 == p8 );
+        assert( p6 == p7 );
+        assert( p1 != p7 );
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
+        assert( p7 == p7 );
+        assert( p8 == p8 );
 
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p8( pBaseClass );
-    assert( p6 == p8 );
-    assert( p1 != p8 );
-    merged = p6.Merge( p8 );
-    // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
-    assert( merged );
-    assert( p6 == p8 );
-    assert( p6 == p7 );
-    assert( p1 != p7 );
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
-    assert( p7 == p7 );
-    assert( p8 == p8 );
+        merged = p5.Merge( p1 );
+        // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
+        assert( !merged );
+        assert( p6 == p8 );
+        assert( p6 == p7 );
+        assert( p1 != p7 );
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
+        assert( p7 == p7 );
+        assert( p8 == p8 );
 
-    merged = p6.Merge( p6 );
-    // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
-    assert( merged );
-    assert( p6 == p8 );
-    assert( p6 == p7 );
-    assert( p1 != p7 );
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
-    assert( p7 == p7 );
-    assert( p8 == p8 );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p9( pBaseClass );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr pA( p9 );
+        assert( p9 == pA );
+        assert( p9 == p8 );
+        assert( p1 != p8 );
+        merged = p9.Merge( p1 );
+        // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2
+        //   and    p4 <---> p1   and   p9 <---> pA
+        assert( !merged );
+        assert( p6 == p8 );
+        assert( p6 == p7 );
+        assert( p1 != p7 );
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
+        assert( p7 == p7 );
+        assert( p8 == p8 );
+        assert( p9 == p9 );
+        assert( pA == pA );
 
-    merged = p6.Merge( p3 );
-    // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
-    assert( merged );
-    assert( p6 == p8 );
-    assert( p6 == p7 );
-    assert( p1 != p7 );
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
-    assert( p7 == p7 );
-    assert( p8 == p8 );
+        merged = p9.Merge( p2 );
+        // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2 <---> p9 <---> pA
+        //   and    p4 <---> p1
+        assert( merged );
+        assert( p6 == p8 );
+        assert( p6 == p7 );
+        assert( p1 != p7 );
+        assert( p6 == p5 );
+        assert( p6 == p2 );
+        assert( p6 == p3 );
+        assert( p5 == p3 );
+        assert( p2 == p3 );
+        assert( p1 == p4 );
+        assert( p2 != p4 );
+        assert( p1 != p5 );
+        assert( p2 != p1 );
+        assert( p3 != p1 );
+        assert( p1 == p1 );
+        assert( p2 == p2 );
+        assert( p3 == p3 );
+        assert( p4 == p4 );
+        assert( p5 == p5 );
+        assert( p6 == p6 );
+        assert( p7 == p7 );
+        assert( p8 == p8 );
+        assert( p9 == p9 );
+        assert( pA == pA );
+    }
 
-    merged = p5.Merge( p1 );
-    // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2   and    p4 <---> p1
-    assert( !merged );
-    assert( p6 == p8 );
-    assert( p6 == p7 );
-    assert( p1 != p7 );
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
-    assert( p7 == p7 );
-    assert( p8 == p8 );
-
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p9( pBaseClass );
-    NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr pA( p9 );
-    assert( p9 == pA );
-    assert( p9 == p8 );
-    assert( p1 != p8 );
-    merged = p9.Merge( p1 );
-    // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2
-    //   and    p4 <---> p1   and   p9 <---> pA
-    assert( !merged );
-    assert( p6 == p8 );
-    assert( p6 == p7 );
-    assert( p1 != p7 );
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
-    assert( p7 == p7 );
-    assert( p8 == p8 );
-    assert( p9 == p9 );
-    assert( pA == pA );
-
-    merged = p9.Merge( p2 );
-    // p7 <---> p6 <---> p8 <---> p3 <---> p5 <---> p2 <---> p9 <---> pA
-    //   and    p4 <---> p1
-    assert( merged );
-    assert( p6 == p8 );
-    assert( p6 == p7 );
-    assert( p1 != p7 );
-    assert( p6 == p5 );
-    assert( p6 == p2 );
-    assert( p6 == p3 );
-    assert( p5 == p3 );
-    assert( p2 == p3 );
-    assert( p1 == p4 );
-    assert( p2 != p4 );
-    assert( p1 != p5 );
-    assert( p2 != p1 );
-    assert( p3 != p1 );
-    assert( p1 == p1 );
-    assert( p2 == p2 );
-    assert( p3 == p3 );
-    assert( p4 == p4 );
-    assert( p5 == p5 );
-    assert( p6 == p6 );
-    assert( p7 == p7 );
-    assert( p8 == p8 );
-    assert( p9 == p9 );
-    assert( pA == pA );
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoRefLinkSwapTests." << endl;
 }
 
 // ----------------------------------------------------------------------------
 
 void DoRefLinkTests( void )
 {
+    cout << "Starting DoRefLinkTests." << endl;
 
     const unsigned int ctorCount = BaseClass::GetCtorCount(); (void) ctorCount;
     const unsigned int dtorCount = BaseClass::GetDtorCount(); (void) dtorCount;
@@ -951,12 +1006,18 @@
     assert( dtorCount + 2 == BaseClass::GetDtorCount() );
     assert( BaseClass::GetCtorCount() == BaseClass::GetDtorCount() );
 
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoRefLinkTests." << endl;
 }
 
 // ----------------------------------------------------------------------------
 
 void DoRefCountNullPointerTests( void )
 {
+    cout << "Starting DoRefCountNullPointerTests." << endl;
+
     BaseClass * pNull = NULL; (void) pNull;
     const unsigned int ctorCount = BaseClass::GetCtorCount(); (void) ctorCount;
     const unsigned int dtorCount = BaseClass::GetDtorCount(); (void) dtorCount;
@@ -965,7 +1026,7 @@
     {
         NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p0;
         NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p1;
-        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p2( p0 );
+        NonConstBase_RefCount_NoConvert_Assert_DontPropagate_ptr p2;
 
         assert( !p0 );
         assert( !p1 );
@@ -1005,12 +1066,19 @@
     }
     assert( ctorCount == BaseClass::GetCtorCount() );
     assert( dtorCount == BaseClass::GetDtorCount() );
+
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoRefCountNullPointerTests." << endl;
 }
 
 // ----------------------------------------------------------------------------
 
 void DoRefLinkNullPointerTests( void )
 {
+    cout << "Starting DoRefLinkNullPointerTests." << endl;
+
     BaseClass * pNull = NULL; (void) pNull;
     const unsigned int ctorCount = BaseClass::GetCtorCount(); (void) ctorCount;
     const unsigned int dtorCount = BaseClass::GetDtorCount(); (void) dtorCount;
@@ -1019,7 +1087,7 @@
     {
         NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p0;
         NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p1;
-        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p2( p0 );
+        NonConstBase_RefLink_NoConvert_Assert_DontPropagate_ptr p2;
 
         assert( !p0 );
         assert( !p1 );
@@ -1059,12 +1127,18 @@
     }
     assert( ctorCount == BaseClass::GetCtorCount() );
     assert( dtorCount == BaseClass::GetDtorCount() );
+
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoRefLinkNullPointerTests." << endl;
 }
 
 // ----------------------------------------------------------------------------
 
 void DoComRefTest( void )
 {
+    cout << "Starting DoComRefTest." << endl;
 
     const unsigned int ctorCount = MimicCOM::GetCtorCount(); (void) ctorCount;
     const unsigned int dtorCount = MimicCOM::GetDtorCount(); (void) dtorCount;
@@ -1090,12 +1164,19 @@
     }
     assert( ctorCount+2 == MimicCOM::GetCtorCount() );
     assert( dtorCount+2 == MimicCOM::GetDtorCount() );
+
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoComRefTest." << endl;
 }
 
 // ----------------------------------------------------------------------------
 
 void DoForwardReferenceTest( void )
 {
+    cout << "Starting DoForwardReferenceTest." << endl;
+
     /** @note These lines should cause the compiler to make a warning message
      about attempting to delete an undefined type.  But it should not produce
      any error messages.
@@ -1112,6 +1193,11 @@
     //Thingy_HeapStorage_ptr p5( p4 );
     //Thingy_HeapStorage_ptr p6;
     //p6 = p5;
+
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoForwardReferenceTest." << endl;
 }
 
 // ----------------------------------------------------------------------------
@@ -1122,25 +1208,63 @@
     class Feline
     {
     public:
-        virtual ~Feline() {}
+
+        static inline bool AllDestroyed( void )
+        {
+            return ( s_constructions == s_destructions );
+        }
+
+        static inline bool ExtraConstructions( void )
+        {
+            return ( s_constructions > s_destructions );
+        }
+
+        static inline bool ExtraDestructions( void )
+        {
+            return ( s_constructions < s_destructions );
+        }
+
+        static inline unsigned int GetCtorCount( void )
+        {
+            return s_constructions;
+        }
+
+        static inline unsigned int GetDtorCount( void )
+        {
+            return s_destructions;
+        }
+
+        Feline( void ) { s_constructions++; }
+        virtual ~Feline() { s_destructions++; }
+        virtual Feline * Clone( void ) const = 0;
+
+    private:
+        static unsigned int s_constructions;
+        static unsigned int s_destructions;
     };
 
-    class Lion : public Feline
+    unsigned int Feline::s_constructions = 0;
+    unsigned int Feline::s_destructions = 0;
+
+    class Tiger : public Feline
     {
     public:
-        virtual ~Lion() {}
+        virtual ~Tiger() {}
+        virtual Tiger * Clone( void ) const { return new Tiger( *this ); }
     };
 
-    class Tiger : public Feline
+    class Lion : public Feline
     {
     public:
-        virtual ~Tiger() {}
+        virtual ~Lion() {}
+        virtual Lion * Clone( void ) const { return new Lion( *this ); }
     };
 
     class Dog
     {
     public:
         virtual ~Dog() {}
+        virtual Dog * Clone( void ) const { return new Dog( *this ); }
     };
 
 }
@@ -1149,88 +1273,188 @@
 
 void DoSmartPtrDynamicCastTests( void )
 {
-    typedef ::Loki::SmartPtr< Feline > FelinePtr;
-    typedef ::Loki::SmartPtr< Lion > LionPtr;
-    typedef ::Loki::SmartPtr< Tiger > TigerPtr;
-    typedef ::Loki::SmartPtr< Dog > DogPtr;
+    cout << "Starting DoSmartPtrDynamicCastTests." << endl;
 
-    Feline * feline = new Lion;
-    Lion * lion = new Lion;
-    Tiger * tiger = new Tiger;
-    Dog * dog = new Dog;
+    typedef ::Loki::SmartPtr< Feline, RefCounted, DisallowConversion, NoCheck > FelinePtr;
+    typedef ::Loki::SmartPtr< Tiger,  RefCounted, DisallowConversion, NoCheck > TigerPtr;
+    typedef ::Loki::SmartPtr< Lion,   RefCounted, DisallowConversion, NoCheck > LionPtr;
+    typedef ::Loki::SmartPtr< Dog,    RefCounted, DisallowConversion, No...
 
[truncated message content]

[Loki-lib-cvs] SF.net SVN: loki-lib:[1097] trunk/test/SmartPtr/main.cpp

[<ric...@us...>]

Revision: 1097
          http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1097&view=rev
Author:   rich_sposato
Date:     2011-09-08 23:37:26 +0000 (Thu, 08 Sep 2011)
Log Message:
-----------
Added tests for DestructiveCopy.

Modified Paths:
--------------
    trunk/test/SmartPtr/main.cpp

Modified: trunk/test/SmartPtr/main.cpp
===================================================================
--- trunk/test/SmartPtr/main.cpp	2011-09-07 22:51:17 UTC (rev 1096)
+++ trunk/test/SmartPtr/main.cpp	2011-09-08 23:37:26 UTC (rev 1097)
@@ -1455,6 +1455,44 @@
 
 // ----------------------------------------------------------------------------
 
+typedef Loki::SmartPtr< BaseClass, DestructiveCopy > DestructiveCopyPtr;
+
+DestructiveCopyPtr MakePointer( void )
+{
+    DestructiveCopyPtr p( new BaseClass );
+    return p;
+}
+
+// ----------------------------------------------------------------------------
+
+void DoDestructiveCopyTest( void )
+{
+    cout << "Starting DoDestructiveCopyTest." << endl;
+
+    {
+        DestructiveCopyPtr p1( new BaseClass );
+        assert( p1 );
+        DestructiveCopyPtr p2;
+        assert( !p2 );
+        p2 = p1;
+        assert( !p1 );
+        assert( p2 );
+        DestructiveCopyPtr p3( p2 );
+        assert( p3 );
+        assert( !p2 );
+        /// @todo The following lines need to be uncommented when bug 3224572 gets fixed.
+//        DestructiveCopyPtr p4( MakePointer() );
+//        assert( p4 );
+    }
+
+    assert( BaseClass::AllDestroyed() );
+    assert( !BaseClass::ExtraConstructions() );
+    assert( !BaseClass::ExtraDestructions() );
+    cout << "Finished DoDestructiveCopyTest." << endl;
+}
+
+// ----------------------------------------------------------------------------
+
 int main( int argc, const char * argv[] )
 {
     bool doThreadTest = false;
@@ -1465,6 +1503,7 @@
     }
 
     DoDeepCopyTests();
+    DoDestructiveCopyTest();
     DoRefLinkTests();
     DoWeakLeakTest();
     DoStrongRefCountTests();

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Loki-lib-cvs] SF.net SVN: loki-lib:[1098] trunk/test/SmartPtr/main.cpp

[<ric...@us...>]

Revision: 1098
          http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1098&view=rev
Author:   rich_sposato
Date:     2011-09-08 23:51:46 +0000 (Thu, 08 Sep 2011)
Log Message:
-----------
Added more tests for DestructiveCopy.

Modified Paths:
--------------
    trunk/test/SmartPtr/main.cpp

Modified: trunk/test/SmartPtr/main.cpp
===================================================================
--- trunk/test/SmartPtr/main.cpp	2011-09-08 23:37:26 UTC (rev 1097)
+++ trunk/test/SmartPtr/main.cpp	2011-09-08 23:51:46 UTC (rev 1098)
@@ -1480,9 +1480,31 @@
         DestructiveCopyPtr p3( p2 );
         assert( p3 );
         assert( !p2 );
+    }
+
+    {
+        const DestructiveCopyPtr p1( new BaseClass );
+        assert( p1 );
+        /** @note The following code won't compile because p1 is declared const. You can test
+         if Loki's SmartPtr DestructiveCopy policy was designed correctly by uncommenting these
+         lines and seeing if any errors occur when compiling. If you see errors about converting
+         from const to non-const, or about assigning a ready-only reference, then DestructiveCopy
+         was designed correctly.
+         */
+//        DestructiveCopyPtr p2;
+//        assert( !p2 );
+//        p2 = p1;
+//        assert( !p1 );
+//        assert( p2 );
+//        DestructiveCopyPtr p3( p2 );
+//        assert( p3 );
+//        assert( !p2 );
+    }
+
+    {
         /// @todo The following lines need to be uncommented when bug 3224572 gets fixed.
-//        DestructiveCopyPtr p4( MakePointer() );
-//        assert( p4 );
+//        DestructiveCopyPtr p1( MakePointer() );
+//        assert( p1 );
     }
 
     assert( BaseClass::AllDestroyed() );

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Loki-lib-cvs] SF.net SVN: loki-lib:[1102] trunk/test/SmartPtr/main.cpp

[<ric...@us...>]

Revision: 1102
          http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1102&view=rev
Author:   rich_sposato
Date:     2011-09-17 02:20:19 +0000 (Sat, 17 Sep 2011)
Log Message:
-----------
Uncommented test for const DestructiveCopy pointer after fixing bug.

Modified Paths:
--------------
    trunk/test/SmartPtr/main.cpp

Modified: trunk/test/SmartPtr/main.cpp
===================================================================
--- trunk/test/SmartPtr/main.cpp	2011-09-17 02:19:01 UTC (rev 1101)
+++ trunk/test/SmartPtr/main.cpp	2011-09-17 02:20:19 UTC (rev 1102)
@@ -40,6 +40,8 @@
 extern void DoLockedPtrTest( void );
 extern void DoLockedStorageTest( void );
 
+extern void TryColvinGibbonsTrick( void );
+
 unsigned int BaseClass::s_constructions = 0;
 unsigned int BaseClass::s_destructions = 0;
 
@@ -1488,23 +1490,23 @@
         /** @note The following code won't compile because p1 is declared const. You can test
          if Loki's SmartPtr DestructiveCopy policy was designed correctly by uncommenting these
          lines and seeing if any errors occur when compiling. If you see errors about converting
-         from const to non-const, or about assigning a ready-only reference, then DestructiveCopy
+         from const to non-const, or about assigning a read-only reference, then DestructiveCopy
          was designed correctly.
          */
-//        DestructiveCopyPtr p2;
-//        assert( !p2 );
-//        p2 = p1;
-//        assert( !p1 );
-//        assert( p2 );
-//        DestructiveCopyPtr p3( p2 );
-//        assert( p3 );
-//        assert( !p2 );
+        DestructiveCopyPtr p2;
+        assert( !p2 );
+        p2 = p1;
+        assert( !p1 );
+        assert( p2 );
+        DestructiveCopyPtr p3( p2 );
+        assert( p3 );
+        assert( !p2 );
     }
 
     {
         /// @todo The following lines need to be uncommented when bug 3224572 gets fixed.
-//        DestructiveCopyPtr p1( MakePointer() );
-//        assert( p1 );
+        DestructiveCopyPtr p1( MakePointer() );
+        assert( p1 );
     }
 
     assert( BaseClass::AllDestroyed() );
@@ -1544,6 +1546,7 @@
     DoRefLinkSwapTests();
 
     DoComRefTest();
+	TryColvinGibbonsTrick();
 
     DoStrongConstTests();
     DoConstConversionTests();

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Loki-lib-cvs] SF.net SVN: loki-lib:[1107] trunk/test/SmartPtr/main.cpp

[<ric...@us...>]

Revision: 1107
          http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1107&view=rev
Author:   rich_sposato
Date:     2011-09-20 18:36:12 +0000 (Tue, 20 Sep 2011)
Log Message:
-----------
Added ability for StrongPtr to handle arrays.

Modified Paths:
--------------
    trunk/test/SmartPtr/main.cpp

Modified: trunk/test/SmartPtr/main.cpp
===================================================================
--- trunk/test/SmartPtr/main.cpp	2011-09-20 17:52:11 UTC (rev 1106)
+++ trunk/test/SmartPtr/main.cpp	2011-09-20 18:36:12 UTC (rev 1107)
@@ -36,6 +36,7 @@
 extern void DoStrongForwardReferenceTest( void );
 extern void DoStrongCompareTests( void );
 extern void DoStrongPtrDynamicCastTests( void );
+extern void DoStrongArrayTests( void );
 
 extern void DoLockedPtrTest( void );
 extern void DoLockedStorageTest( void );
@@ -1546,7 +1547,7 @@
     DoRefLinkSwapTests();
 
     DoComRefTest();
-	TryColvinGibbonsTrick();
+    TryColvinGibbonsTrick();
 
     DoStrongConstTests();
     DoConstConversionTests();
@@ -1554,6 +1555,7 @@
     DoInheritanceConversionTests();
     DoSmartPtrDynamicCastTests();
     DoStrongPtrDynamicCastTests();
+    DoStrongArrayTests();
 
 #if defined (LOKI_OBJECT_LEVEL_THREADING) || defined (LOKI_CLASS_LEVEL_THREADING)
     if ( doThreadTest )

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Loki-lib-cvs] SF.net SVN: loki-lib:[1131] trunk/test/SmartPtr/main.cpp

[<ric...@us...>]

Revision: 1131
          http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1131&view=rev
Author:   rich_sposato
Date:     2011-10-03 04:56:54 +0000 (Mon, 03 Oct 2011)
Log Message:
-----------
Added void lines to remove compiler warnings. Commented out inappropriate tests. Added call to single-owner test for StrongPtr.

Modified Paths:
--------------
    trunk/test/SmartPtr/main.cpp

Modified: trunk/test/SmartPtr/main.cpp
===================================================================
--- trunk/test/SmartPtr/main.cpp	2011-10-03 04:52:52 UTC (rev 1130)
+++ trunk/test/SmartPtr/main.cpp	2011-10-03 04:56:54 UTC (rev 1131)
@@ -36,6 +36,7 @@
 extern void DoStrongForwardReferenceTest( void );
 extern void DoStrongCompareTests( void );
 extern void DoStrongPtrDynamicCastTests( void );
+extern void DoSingleOwnerTests( void );
 extern void DoStrongArrayTests( void );
 
 extern void DoLockedPtrTest( void );
@@ -60,6 +61,10 @@
     NoCheck, DefaultSPStorage, PropagateConst >
     Thingy_DefaultStorage_ptr;
 
+//typedef Loki::SmartPtr< Thingy, RefCountedMTAdj< >, DisallowConversion,
+//    AssertCheck, DefaultSPStorage, PropagateConst >
+//    Thingy_Locked_ptr;
+
 typedef Loki::SmartPtr< Thingy, RefCounted, DisallowConversion,
     AssertCheck, HeapStorage, PropagateConst >
     Thingy_HeapStorage_ptr;
@@ -1425,20 +1430,23 @@
          from const to non-const, or about assigning a read-only reference, then DestructiveCopy
          was designed correctly.
          */
-        DestructiveCopyPtr p2;
-        assert( !p2 );
-        p2 = p1;
-        assert( !p1 );
-        assert( p2 );
-        DestructiveCopyPtr p3( p2 );
-        assert( p3 );
-        assert( !p2 );
+        //DestructiveCopyPtr p2;
+        //assert( !p2 );
+        //p2 = p1;
+        //assert( !p1 );
+        //assert( p2 );
+        //DestructiveCopyPtr p3( p2 );
+        //assert( p3 );
+        //assert( !p2 );
     }
 
     {
         /// @todo The following lines need to be uncommented when bug 3224572 gets fixed.
         DestructiveCopyPtr p1( MakePointer() );
         assert( p1 );
+        DestructiveCopyPtr p2;
+        p2 = MakePointer();
+        assert( p2 );
     }
 
     assert( BaseClass::AllDestroyed() );
@@ -1497,10 +1505,12 @@
         try
         {
             Tiger & p4 = sp2[ 4 ];
+            (void)p4;
             assert( false );
         }
         catch ( const ::std::out_of_range & ex )
         {
+            (void)ex;
             assert( true );
         }
 
@@ -1508,10 +1518,12 @@
         try
         {
             Tiger & p8 = sp1[ 8 ];
+            (void)p8;
             assert( false );
         }
         catch ( const ::std::out_of_range & ex )
         {
+            (void)ex;
             assert( true );
         }
 
@@ -1540,20 +1552,24 @@
         try
         {
             Tiger & p4 = sp1[ 4 ];
+            (void)p4;
             assert( false );
         }
         catch ( const ::std::out_of_range & ex )
         {
+            (void)ex;
             assert( true );
         }
 
         try
         {
             Tiger & p8 = sp2[ 8 ];
+            (void)p8;
             assert( false );
         }
         catch ( const ::std::out_of_range & ex )
         {
+            (void)ex;
             assert( true );
         }
 
@@ -1563,10 +1579,12 @@
         try
         {
             const Tiger & p4 = sp3[ 4 ];
+            (void)p4;
             assert( false );
         }
         catch ( const ::std::out_of_range & ex )
         {
+            (void)ex;
             assert( true );
         }
 
@@ -1576,10 +1594,12 @@
         try
         {
             const Tiger & p8 = sp5[ 8 ];
+            (void)p8;
             assert( false );
         }
         catch ( const ::std::out_of_range & ex )
         {
+            (void)ex;
             assert( true );
         }
 
@@ -1622,6 +1642,7 @@
     DoStrongReleaseTests();
     DoWeakCycleTests();
     DoStrongCompareTests();
+    DoSingleOwnerTests();
 
     DoForwardReferenceTest();
     DoStrongForwardReferenceTest();
@@ -1633,7 +1654,7 @@
     DoRefLinkSwapTests();
 
     DoComRefTest();
-    TryColvinGibbonsTrick();
+//    TryColvinGibbonsTrick();
 
     DoStrongConstTests();
     DoConstConversionTests();

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.