Renamed tests to separate owner/observer

cschreib · cschreib · commit 55ada96e8c1e · 2021-10-31T17:43:37.000+01:00
diff --git a/tests/runtime_tests.cpp b/tests/runtime_tests.cpp
@@ -2,7 +2,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("default constructor", "[construction]") {
+TEST_CASE("owner default constructor", "[owner_construction]") {
     {
         test_ptr ptr{};
         REQUIRE(instances == 0);
@@ -13,7 +13,7 @@ TEST_CASE("default constructor", "[construction]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("default constructor with deleter", "[construction]") {
+TEST_CASE("owner default constructor with deleter", "[owner_construction]") {
     {
         test_ptr_with_deleter ptr{};
         REQUIRE(instances == 0);
@@ -27,7 +27,7 @@ TEST_CASE("default constructor with deleter", "[construction]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("nullptr constructor", "[construction]") {
+TEST_CASE("owner nullptr constructor", "[owner_construction]") {
     {
         test_ptr ptr{nullptr};
         REQUIRE(instances == 0);
@@ -38,7 +38,7 @@ TEST_CASE("nullptr constructor", "[construction]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("nullptr constructor with deleter", "[construction]") {
+TEST_CASE("owner nullptr constructor with deleter", "[owner_construction]") {
     {
         test_ptr_with_deleter ptr{nullptr, test_deleter{42}};
         REQUIRE(instances == 0);
@@ -52,7 +52,7 @@ TEST_CASE("nullptr constructor with deleter", "[construction]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("move constructor", "[construction]") {
+TEST_CASE("owner move constructor", "[owner_construction]") {
     {
         test_ptr ptr_orig(new test_object);
         {
@@ -68,7 +68,7 @@ TEST_CASE("move constructor", "[construction]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("move constructor with deleter", "[construction]") {
+TEST_CASE("owner move constructor with deleter", "[owner_construction]") {
     {
         test_ptr_with_deleter ptr_orig(new test_object, test_deleter{42});
         {
@@ -88,7 +88,7 @@ TEST_CASE("move constructor with deleter", "[construction]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("acquiring constructor", "[construction]") {
+TEST_CASE("owner acquiring constructor", "[owner_construction]") {
     {
         test_ptr ptr{new test_object};
         REQUIRE(instances == 1);
@@ -99,7 +99,7 @@ TEST_CASE("acquiring constructor", "[construction]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("acquiring constructor with deleter", "[construction]") {
+TEST_CASE("owner acquiring constructor with deleter", "[owner_construction]") {
     {
         test_ptr_with_deleter ptr{new test_object, test_deleter{42}};
         REQUIRE(instances == 1);
@@ -113,7 +113,7 @@ TEST_CASE("acquiring constructor with deleter", "[construction]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("implicit conversion constructor", "[construction]") {
+TEST_CASE("owner implicit conversion constructor", "[owner_construction]") {
     {
         test_ptr_derived ptr_orig{new test_object_derived};
         {
@@ -132,7 +132,7 @@ TEST_CASE("implicit conversion constructor", "[construction]") {
     REQUIRE(instances_derived == 0);
 }
 
-TEST_CASE("implicit conversion constructor with deleter", "[construction]") {
+TEST_CASE("owner implicit conversion constructor with deleter", "[owner_construction]") {
     {
         test_ptr_derived_with_deleter ptr_orig{new test_object_derived, test_deleter{42}};
         {
@@ -155,7 +155,7 @@ TEST_CASE("implicit conversion constructor with deleter", "[construction]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("explicit conversion constructor", "[construction]") {
+TEST_CASE("owner explicit conversion constructor", "[owner_construction]") {
     {
         test_ptr ptr_orig{new test_object_derived};
         {
@@ -175,7 +175,7 @@ TEST_CASE("explicit conversion constructor", "[construction]") {
     REQUIRE(instances_derived == 0);
 }
 
-TEST_CASE("explicit conversion constructor with deleter", "[construction]") {
+TEST_CASE("owner explicit conversion constructor with deleter", "[owner_construction]") {
     {
         test_ptr_with_deleter ptr_orig{new test_object_derived, test_deleter{42}};
         {
@@ -199,7 +199,7 @@ TEST_CASE("explicit conversion constructor with deleter", "[construction]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("move assignment operator", "[assignment]") {
+TEST_CASE("owner move assignment operator", "[owner_assignment]") {
     {
         test_ptr ptr_orig(new test_object);
         {
@@ -216,7 +216,7 @@ TEST_CASE("move assignment operator", "[assignment]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("move assignment operator with deleter", "[assignment]") {
+TEST_CASE("owner move assignment operator with deleter", "[owner_assignment]") {
     {
         test_ptr_with_deleter ptr_orig(new test_object, test_deleter{42});
         {
@@ -237,7 +237,7 @@ TEST_CASE("move assignment operator with deleter", "[assignment]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("reset to null", "[utility]") {
+TEST_CASE("owner reset to null", "[owner_utility]") {
     {
         test_ptr ptr(new test_object);
         ptr.reset();
@@ -249,7 +249,7 @@ TEST_CASE("reset to null", "[utility]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("reset to null with deleter", "[utility]") {
+TEST_CASE("owner reset to null with deleter", "[owner_utility]") {
     {
         test_ptr_with_deleter ptr(new test_object, test_deleter{42});
         ptr.reset();
@@ -264,7 +264,7 @@ TEST_CASE("reset to null with deleter", "[utility]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("reset to new", "[utility]") {
+TEST_CASE("owner reset to new", "[owner_utility]") {
     {
         test_ptr ptr(new test_object);
         ptr.reset(new test_object);
@@ -276,7 +276,7 @@ TEST_CASE("reset to new", "[utility]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("reset to new with deleter", "[utility]") {
+TEST_CASE("owner reset to new with deleter", "[owner_utility]") {
     {
         test_ptr_with_deleter ptr(new test_object, test_deleter{42});
         ptr.reset(new test_object);
@@ -291,7 +291,7 @@ TEST_CASE("reset to new with deleter", "[utility]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("reset to new with new deleter", "[utility]") {
+TEST_CASE("owner reset to new with new deleter", "[owner_utility]") {
     {
         test_ptr_with_deleter ptr(new test_object, test_deleter{42});
         ptr.reset(new test_object, test_deleter{43});
@@ -306,7 +306,7 @@ TEST_CASE("reset to new with new deleter", "[utility]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("swap no instance", "[utility]") {
+TEST_CASE("owner swap no instance", "[owner_utility]") {
     {
         test_ptr ptr_orig;
         test_ptr ptr;
@@ -319,7 +319,7 @@ TEST_CASE("swap no instance", "[utility]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("swap no instance with deleter", "[utility]") {
+TEST_CASE("owner swap no instance with deleter", "[owner_utility]") {
     {
         test_ptr_with_deleter ptr_orig(nullptr, test_deleter{42});
         test_ptr_with_deleter ptr(nullptr, test_deleter{43});
@@ -338,7 +338,7 @@ TEST_CASE("swap no instance with deleter", "[utility]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("swap one instance", "[utility]") {
+TEST_CASE("owner swap one instance", "[owner_utility]") {
     {
         test_ptr ptr_orig(new test_object);
         test_ptr ptr;
@@ -351,7 +351,7 @@ TEST_CASE("swap one instance", "[utility]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("swap one instance with deleter", "[utility]") {
+TEST_CASE("owner swap one instance with deleter", "[owner_utility]") {
     {
         test_ptr_with_deleter ptr_orig(new test_object, test_deleter{42});
         test_ptr_with_deleter ptr(nullptr, test_deleter{43});
@@ -370,7 +370,7 @@ TEST_CASE("swap one instance with deleter", "[utility]") {
     REQUIRE(instances_deleter == 0);
 }
 
-TEST_CASE("swap two instances", "[utility]") {
+TEST_CASE("owner swap two instances", "[owner_utility]") {
     {
         test_ptr ptr_orig(new test_object);
         test_object* ptr_orig_raw = ptr_orig.get();
@@ -385,7 +385,7 @@ TEST_CASE("swap two instances", "[utility]") {
     REQUIRE(instances == 0);
 }
 
-TEST_CASE("swap two instances with deleter", "[utility]") {
+TEST_CASE("owner swap two instances with deleter", "[owner_utility]") {
     {
         test_ptr_with_deleter ptr_orig(new test_object, test_deleter{42});
         test_object* ptr_orig_raw = ptr_orig.get();

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`#include <catch2/catch_test_macros.hpp>`
`4`	`4`
`5`		`-TEST_CASE("default constructor", "[construction]") {`
	`5`	`+TEST_CASE("owner default constructor", "[owner_construction]") {`
`6`	`6`	`{`
`7`	`7`	`test_ptr ptr{};`
`8`	`8`	`REQUIRE(instances == 0);`
`@@ -13,7 +13,7 @@ TEST_CASE("default constructor", "[construction]") {`
`13`	`13`	`REQUIRE(instances == 0);`
`14`	`14`	`}`
`15`	`15`
`16`		`-TEST_CASE("default constructor with deleter", "[construction]") {`
	`16`	`+TEST_CASE("owner default constructor with deleter", "[owner_construction]") {`
`17`	`17`	`{`
`18`	`18`	`test_ptr_with_deleter ptr{};`
`19`	`19`	`REQUIRE(instances == 0);`
`@@ -27,7 +27,7 @@ TEST_CASE("default constructor with deleter", "[construction]") {`
`27`	`27`	`REQUIRE(instances_deleter == 0);`
`28`	`28`	`}`
`29`	`29`
`30`		`-TEST_CASE("nullptr constructor", "[construction]") {`
	`30`	`+TEST_CASE("owner nullptr constructor", "[owner_construction]") {`
`31`	`31`	`{`
`32`	`32`	`test_ptr ptr{nullptr};`
`33`	`33`	`REQUIRE(instances == 0);`
`@@ -38,7 +38,7 @@ TEST_CASE("nullptr constructor", "[construction]") {`
`38`	`38`	`REQUIRE(instances == 0);`
`39`	`39`	`}`
`40`	`40`
`41`		`-TEST_CASE("nullptr constructor with deleter", "[construction]") {`
	`41`	`+TEST_CASE("owner nullptr constructor with deleter", "[owner_construction]") {`
`42`	`42`	`{`
`43`	`43`	`test_ptr_with_deleter ptr{nullptr, test_deleter{42}};`
`44`	`44`	`REQUIRE(instances == 0);`
`@@ -52,7 +52,7 @@ TEST_CASE("nullptr constructor with deleter", "[construction]") {`
`52`	`52`	`REQUIRE(instances_deleter == 0);`
`53`	`53`	`}`
`54`	`54`
`55`		`-TEST_CASE("move constructor", "[construction]") {`
	`55`	`+TEST_CASE("owner move constructor", "[owner_construction]") {`
`56`	`56`	`{`
`57`	`57`	`test_ptr ptr_orig(new test_object);`
`58`	`58`	`{`
`@@ -68,7 +68,7 @@ TEST_CASE("move constructor", "[construction]") {`
`68`	`68`	`REQUIRE(instances == 0);`
`69`	`69`	`}`
`70`	`70`
`71`		`-TEST_CASE("move constructor with deleter", "[construction]") {`
	`71`	`+TEST_CASE("owner move constructor with deleter", "[owner_construction]") {`
`72`	`72`	`{`
`73`	`73`	`test_ptr_with_deleter ptr_orig(new test_object, test_deleter{42});`
`74`	`74`	`{`
`@@ -88,7 +88,7 @@ TEST_CASE("move constructor with deleter", "[construction]") {`
`88`	`88`	`REQUIRE(instances_deleter == 0);`
`89`	`89`	`}`
`90`	`90`
`91`		`-TEST_CASE("acquiring constructor", "[construction]") {`
	`91`	`+TEST_CASE("owner acquiring constructor", "[owner_construction]") {`
`92`	`92`	`{`
`93`	`93`	`test_ptr ptr{new test_object};`
`94`	`94`	`REQUIRE(instances == 1);`
`@@ -99,7 +99,7 @@ TEST_CASE("acquiring constructor", "[construction]") {`
`99`	`99`	`REQUIRE(instances == 0);`
`100`	`100`	`}`
`101`	`101`
`102`		`-TEST_CASE("acquiring constructor with deleter", "[construction]") {`
	`102`	`+TEST_CASE("owner acquiring constructor with deleter", "[owner_construction]") {`
`103`	`103`	`{`
`104`	`104`	`test_ptr_with_deleter ptr{new test_object, test_deleter{42}};`
`105`	`105`	`REQUIRE(instances == 1);`
`@@ -113,7 +113,7 @@ TEST_CASE("acquiring constructor with deleter", "[construction]") {`
`113`	`113`	`REQUIRE(instances_deleter == 0);`
`114`	`114`	`}`
`115`	`115`
`116`		`-TEST_CASE("implicit conversion constructor", "[construction]") {`
	`116`	`+TEST_CASE("owner implicit conversion constructor", "[owner_construction]") {`
`117`	`117`	`{`
`118`	`118`	`test_ptr_derived ptr_orig{new test_object_derived};`
`119`	`119`	`{`
`@@ -132,7 +132,7 @@ TEST_CASE("implicit conversion constructor", "[construction]") {`
`132`	`132`	`REQUIRE(instances_derived == 0);`
`133`	`133`	`}`
`134`	`134`
`135`		`-TEST_CASE("implicit conversion constructor with deleter", "[construction]") {`
	`135`	`+TEST_CASE("owner implicit conversion constructor with deleter", "[owner_construction]") {`
`136`	`136`	`{`
`137`	`137`	`test_ptr_derived_with_deleter ptr_orig{new test_object_derived, test_deleter{42}};`
`138`	`138`	`{`
`@@ -155,7 +155,7 @@ TEST_CASE("implicit conversion constructor with deleter", "[construction]") {`
`155`	`155`	`REQUIRE(instances_deleter == 0);`
`156`	`156`	`}`
`157`	`157`
`158`		`-TEST_CASE("explicit conversion constructor", "[construction]") {`
	`158`	`+TEST_CASE("owner explicit conversion constructor", "[owner_construction]") {`
`159`	`159`	`{`
`160`	`160`	`test_ptr ptr_orig{new test_object_derived};`
`161`	`161`	`{`
`@@ -175,7 +175,7 @@ TEST_CASE("explicit conversion constructor", "[construction]") {`
`175`	`175`	`REQUIRE(instances_derived == 0);`
`176`	`176`	`}`
`177`	`177`
`178`		`-TEST_CASE("explicit conversion constructor with deleter", "[construction]") {`
	`178`	`+TEST_CASE("owner explicit conversion constructor with deleter", "[owner_construction]") {`
`179`	`179`	`{`
`180`	`180`	`test_ptr_with_deleter ptr_orig{new test_object_derived, test_deleter{42}};`
`181`	`181`	`{`
`@@ -199,7 +199,7 @@ TEST_CASE("explicit conversion constructor with deleter", "[construction]") {`
`199`	`199`	`REQUIRE(instances_deleter == 0);`
`200`	`200`	`}`
`201`	`201`
`202`		`-TEST_CASE("move assignment operator", "[assignment]") {`
	`202`	`+TEST_CASE("owner move assignment operator", "[owner_assignment]") {`
`203`	`203`	`{`
`204`	`204`	`test_ptr ptr_orig(new test_object);`
`205`	`205`	`{`
`@@ -216,7 +216,7 @@ TEST_CASE("move assignment operator", "[assignment]") {`
`216`	`216`	`REQUIRE(instances == 0);`
`217`	`217`	`}`
`218`	`218`
`219`		`-TEST_CASE("move assignment operator with deleter", "[assignment]") {`
	`219`	`+TEST_CASE("owner move assignment operator with deleter", "[owner_assignment]") {`
`220`	`220`	`{`
`221`	`221`	`test_ptr_with_deleter ptr_orig(new test_object, test_deleter{42});`
`222`	`222`	`{`
`@@ -237,7 +237,7 @@ TEST_CASE("move assignment operator with deleter", "[assignment]") {`
`237`	`237`	`REQUIRE(instances_deleter == 0);`
`238`	`238`	`}`
`239`	`239`
`240`		`-TEST_CASE("reset to null", "[utility]") {`
	`240`	`+TEST_CASE("owner reset to null", "[owner_utility]") {`
`241`	`241`	`{`
`242`	`242`	`test_ptr ptr(new test_object);`
`243`	`243`	`ptr.reset();`
`@@ -249,7 +249,7 @@ TEST_CASE("reset to null", "[utility]") {`
`249`	`249`	`REQUIRE(instances == 0);`
`250`	`250`	`}`
`251`	`251`
`252`		`-TEST_CASE("reset to null with deleter", "[utility]") {`
	`252`	`+TEST_CASE("owner reset to null with deleter", "[owner_utility]") {`
`253`	`253`	`{`
`254`	`254`	`test_ptr_with_deleter ptr(new test_object, test_deleter{42});`
`255`	`255`	`ptr.reset();`
`@@ -264,7 +264,7 @@ TEST_CASE("reset to null with deleter", "[utility]") {`
`264`	`264`	`REQUIRE(instances_deleter == 0);`
`265`	`265`	`}`
`266`	`266`
`267`		`-TEST_CASE("reset to new", "[utility]") {`
	`267`	`+TEST_CASE("owner reset to new", "[owner_utility]") {`
`268`	`268`	`{`
`269`	`269`	`test_ptr ptr(new test_object);`
`270`	`270`	`ptr.reset(new test_object);`
`@@ -276,7 +276,7 @@ TEST_CASE("reset to new", "[utility]") {`
`276`	`276`	`REQUIRE(instances == 0);`
`277`	`277`	`}`
`278`	`278`
`279`		`-TEST_CASE("reset to new with deleter", "[utility]") {`
	`279`	`+TEST_CASE("owner reset to new with deleter", "[owner_utility]") {`
`280`	`280`	`{`
`281`	`281`	`test_ptr_with_deleter ptr(new test_object, test_deleter{42});`
`282`	`282`	`ptr.reset(new test_object);`
`@@ -291,7 +291,7 @@ TEST_CASE("reset to new with deleter", "[utility]") {`
`291`	`291`	`REQUIRE(instances_deleter == 0);`
`292`	`292`	`}`
`293`	`293`
`294`		`-TEST_CASE("reset to new with new deleter", "[utility]") {`
	`294`	`+TEST_CASE("owner reset to new with new deleter", "[owner_utility]") {`
`295`	`295`	`{`
`296`	`296`	`test_ptr_with_deleter ptr(new test_object, test_deleter{42});`
`297`	`297`	`ptr.reset(new test_object, test_deleter{43});`
`@@ -306,7 +306,7 @@ TEST_CASE("reset to new with new deleter", "[utility]") {`
`306`	`306`	`REQUIRE(instances_deleter == 0);`
`307`	`307`	`}`
`308`	`308`
`309`		`-TEST_CASE("swap no instance", "[utility]") {`
	`309`	`+TEST_CASE("owner swap no instance", "[owner_utility]") {`
`310`	`310`	`{`
`311`	`311`	`test_ptr ptr_orig;`
`312`	`312`	`test_ptr ptr;`
`@@ -319,7 +319,7 @@ TEST_CASE("swap no instance", "[utility]") {`
`319`	`319`	`REQUIRE(instances == 0);`
`320`	`320`	`}`
`321`	`321`
`322`		`-TEST_CASE("swap no instance with deleter", "[utility]") {`
	`322`	`+TEST_CASE("owner swap no instance with deleter", "[owner_utility]") {`
`323`	`323`	`{`
`324`	`324`	`test_ptr_with_deleter ptr_orig(nullptr, test_deleter{42});`
`325`	`325`	`test_ptr_with_deleter ptr(nullptr, test_deleter{43});`
`@@ -338,7 +338,7 @@ TEST_CASE("swap no instance with deleter", "[utility]") {`
`338`	`338`	`REQUIRE(instances_deleter == 0);`
`339`	`339`	`}`
`340`	`340`
`341`		`-TEST_CASE("swap one instance", "[utility]") {`
	`341`	`+TEST_CASE("owner swap one instance", "[owner_utility]") {`
`342`	`342`	`{`
`343`	`343`	`test_ptr ptr_orig(new test_object);`
`344`	`344`	`test_ptr ptr;`
`@@ -351,7 +351,7 @@ TEST_CASE("swap one instance", "[utility]") {`
`351`	`351`	`REQUIRE(instances == 0);`
`352`	`352`	`}`
`353`	`353`
`354`		`-TEST_CASE("swap one instance with deleter", "[utility]") {`
	`354`	`+TEST_CASE("owner swap one instance with deleter", "[owner_utility]") {`
`355`	`355`	`{`
`356`	`356`	`test_ptr_with_deleter ptr_orig(new test_object, test_deleter{42});`
`357`	`357`	`test_ptr_with_deleter ptr(nullptr, test_deleter{43});`
`@@ -370,7 +370,7 @@ TEST_CASE("swap one instance with deleter", "[utility]") {`
`370`	`370`	`REQUIRE(instances_deleter == 0);`
`371`	`371`	`}`
`372`	`372`
`373`		`-TEST_CASE("swap two instances", "[utility]") {`
	`373`	`+TEST_CASE("owner swap two instances", "[owner_utility]") {`
`374`	`374`	`{`
`375`	`375`	`test_ptr ptr_orig(new test_object);`
`376`	`376`	`test_object* ptr_orig_raw = ptr_orig.get();`
`@@ -385,7 +385,7 @@ TEST_CASE("swap two instances", "[utility]") {`
`385`	`385`	`REQUIRE(instances == 0);`
`386`	`386`	`}`
`387`	`387`
`388`		`-TEST_CASE("swap two instances with deleter", "[utility]") {`
	`388`	`+TEST_CASE("owner swap two instances with deleter", "[owner_utility]") {`
`389`	`389`	`{`
`390`	`390`	`test_ptr_with_deleter ptr_orig(new test_object, test_deleter{42});`
`391`	`391`	`test_object* ptr_orig_raw = ptr_orig.get();`