Refactor test cases for pmr_memory_resource, pmr_new, pmr_allocator, pmr_block_pool, and pmr_monotonic_buffer_resource

Author: mutouyun

test/pmr/test_pmr_allocator.cpp

@@ -6,12 +6,12 @@
 
 #include "libpmr/allocator.h"
 
-TEST(allocator, construct) {
+TEST(pmr_allocator, construct) {
   pmr::allocator alc;
   SUCCEED();
 }
 
-TEST(allocator, construct_value_initialization) {
+TEST(pmr_allocator, construct_value_initialization) {
   pmr::allocator alc{};
   auto p = alc.allocate(128);
   EXPECT_NE(p, nullptr);
@@ -32,7 +32,7 @@ class dummy_resource {
 
 } // namespace
 
-TEST(allocator, construct_copy_move) {
+TEST(pmr_allocator, construct_copy_move) {
   pmr::new_delete_resource mem_res;
   dummy_resource dummy_res;
   pmr::allocator alc1{&mem_res}, alc2{&dummy_res};
@@ -54,7 +54,7 @@ TEST(allocator, construct_copy_move) {
   ASSERT_NO_THROW(alc5.deallocate(p, 128));
 }
 
-TEST(allocator, swap) {
+TEST(pmr_allocator, swap) {
   pmr::new_delete_resource mem_res;
   dummy_resource dummy_res;
   pmr::allocator alc1{&mem_res}, alc2{&dummy_res};
@@ -65,14 +65,14 @@ TEST(allocator, swap) {
   ASSERT_EQ(alc1.allocate(128), nullptr);
 }
 
-TEST(allocator, invalid_alloc_free) {
+TEST(pmr_allocator, invalid_alloc_free) {
   pmr::allocator alc1;
   EXPECT_EQ(alc1.allocate(0), nullptr);
   EXPECT_NO_THROW(alc1.deallocate(nullptr, 128));
   EXPECT_NO_THROW(alc1.deallocate(nullptr, 0));
   EXPECT_NO_THROW(alc1.deallocate(&alc1, 0));
 }
 
-TEST(allocator, sizeof) {
+TEST(pmr_allocator, sizeof) {
   EXPECT_EQ(sizeof(pmr::allocator), sizeof(void *) * 2);
 }

test/pmr/test_pmr_block_pool.cpp

@@ -6,7 +6,7 @@
 
 #include "libpmr/block_pool.h"
 
-TEST(block_pool, central_cache_allocator) {
+TEST(pmr_block_pool, central_cache_allocator) {
   auto &a = pmr::central_cache_allocator();
   ASSERT_FALSE(nullptr == a.allocate(1));
   ASSERT_FALSE(nullptr == a.allocate(10));
@@ -15,7 +15,7 @@ TEST(block_pool, central_cache_allocator) {
   ASSERT_FALSE(nullptr == a.allocate(10000));
 }
 
-TEST(block_pool, block) {
+TEST(pmr_block_pool, block) {
   pmr::block<1> b1;
   EXPECT_EQ(sizeof(b1), (std::max)(alignof(std::max_align_t), sizeof(void *)));
   pmr::block<sizeof(void *)> b2;
@@ -24,7 +24,7 @@ TEST(block_pool, block) {
   EXPECT_EQ(sizeof(b3), (std::max)(alignof(std::max_align_t), sizeof(void *) * 2));
 }
 
-TEST(block_pool, central_cache_pool_ctor) {
+TEST(pmr_block_pool, central_cache_pool_ctor) {
   ASSERT_FALSE((std::is_default_constructible<pmr::central_cache_pool<pmr::block<1>, 1>>::value));
   ASSERT_FALSE((std::is_copy_constructible<pmr::central_cache_pool<pmr::block<1>, 1>>::value));
   ASSERT_FALSE((std::is_move_constructible<pmr::central_cache_pool<pmr::block<1>, 1>>::value));
@@ -62,15 +62,15 @@ TEST(block_pool, central_cache_pool_ctor) {
   }
 }
 
-TEST(block_pool, ctor) {
+TEST(pmr_block_pool, ctor) {
   ASSERT_TRUE ((std::is_default_constructible<pmr::block_pool<1, 1>>::value));
   ASSERT_FALSE((std::is_copy_constructible<pmr::block_pool<1, 1>>::value));
-  ASSERT_FALSE((std::is_move_constructible<pmr::block_pool<1, 1>>::value));
+  ASSERT_TRUE ((std::is_move_constructible<pmr::block_pool<1, 1>>::value));
   ASSERT_FALSE((std::is_copy_assignable<pmr::block_pool<1, 1>>::value));
   ASSERT_FALSE((std::is_move_assignable<pmr::block_pool<1, 1>>::value));
 }
 
-TEST(block_pool, allocate) {
+TEST(pmr_block_pool, allocate) {
   std::vector<void *> v;
   pmr::block_pool<1, 1> pool;
   for (int i = 0; i < 100; ++i) {

test/pmr/test_pmr_memory_resource.cpp

@@ -24,7 +24,7 @@ void *test_mr(T &&mr, std::size_t bytes, std::size_t alignment) {
 
 } // namespace
 
-TEST(memory_resource, traits) {
+TEST(pmr_memory_resource, traits) {
   EXPECT_FALSE(pmr::has_allocate<void>::value);
   EXPECT_FALSE(pmr::has_allocate<int>::value);
   EXPECT_FALSE(pmr::has_allocate<std::vector<int>>::value);
@@ -44,7 +44,7 @@ TEST(memory_resource, traits) {
 #endif
 }
 
-TEST(memory_resource, new_delete_resource) {
+TEST(pmr_memory_resource, new_delete_resource) {
   pmr::new_delete_resource mem_res;
 
   EXPECT_EQ(test_mr(mem_res, 0, 0), nullptr);

test/pmr/test_pmr_monotonic_buffer_resource.cpp

@@ -7,7 +7,7 @@
 
 #include "libpmr/monotonic_buffer_resource.h"
 
-TEST(monotonic_buffer_resource, construct) {
+TEST(pmr_monotonic_buffer_resource, construct) {
   { pmr::monotonic_buffer_resource tmp; }
   pmr::monotonic_buffer_resource{};
   pmr::monotonic_buffer_resource{pmr::allocator{}};
@@ -18,14 +18,14 @@ TEST(monotonic_buffer_resource, construct) {
   SUCCEED();
 }
 
-TEST(monotonic_buffer_resource, no_copy) {
+TEST(pmr_monotonic_buffer_resource, no_copy) {
   EXPECT_FALSE(std::is_copy_constructible<pmr::monotonic_buffer_resource>::value);
   EXPECT_FALSE(std::is_copy_assignable<pmr::monotonic_buffer_resource>::value);
   EXPECT_FALSE(std::is_move_constructible<pmr::monotonic_buffer_resource>::value);
   EXPECT_FALSE(std::is_move_assignable<pmr::monotonic_buffer_resource>::value);
 }
 
-TEST(monotonic_buffer_resource, upstream_resource) {
+TEST(pmr_monotonic_buffer_resource, upstream_resource) {
   struct dummy_allocator {
     bool allocated = false;
     void *allocate(std::size_t, std::size_t) noexcept { allocated = true; return nullptr; }
@@ -52,7 +52,7 @@ struct dummy_allocator {
 
 } // namespace
 
-TEST(monotonic_buffer_resource, allocate) {
+TEST(pmr_monotonic_buffer_resource, allocate) {
   dummy_allocator dummy;
   {
     pmr::monotonic_buffer_resource tmp{&dummy};
@@ -76,7 +76,7 @@ TEST(monotonic_buffer_resource, allocate) {
   ASSERT_EQ(dummy.allocated, 0);
 }
 
-TEST(monotonic_buffer_resource, allocate_by_buffer) {
+TEST(pmr_monotonic_buffer_resource, allocate_by_buffer) {
   dummy_allocator dummy;
   std::array<imp::byte, 4096> buffer;
   {
@@ -95,7 +95,7 @@ TEST(monotonic_buffer_resource, allocate_by_buffer) {
   ASSERT_EQ(dummy.allocated, 0);
 }
 
-TEST(monotonic_buffer_resource, release) {
+TEST(pmr_monotonic_buffer_resource, release) {
   dummy_allocator dummy;
   {
     pmr::monotonic_buffer_resource tmp{&dummy};

test/pmr/test_pmr_new.cpp

@@ -68,6 +68,8 @@ TEST(pmr_new, new$array) {
 
 namespace {
 
+int construct_count__ = 0;
+
 class Base {
 public:
   virtual ~Base() = default;
@@ -76,7 +78,14 @@ class Base {
 
 class Derived : public Base {
 public:
-  Derived(int value) : value_(value) {}
+  Derived(int value) : value_(value) {
+    construct_count__ = value_;
+  }
+
+  ~Derived() override {
+    construct_count__ = 0;
+  }
+
   int get() const override { return value_; }
 
 private:
@@ -89,9 +98,19 @@ TEST(pmr_new, delete$poly) {
   Base *p = pmr::new$<Derived>(-1);
   ASSERT_NE(p, nullptr);
   ASSERT_EQ(p->get(), -1);
+  ASSERT_EQ(construct_count__, -1);
   pmr::delete$(p);
+  ASSERT_EQ(construct_count__, 0);
 
   ASSERT_EQ(p, pmr::new$<Derived>((std::numeric_limits<int>::max)()));
   ASSERT_EQ(p->get(), (std::numeric_limits<int>::max)());
+  ASSERT_EQ(construct_count__, (std::numeric_limits<int>::max)());
+  pmr::delete$(p);
+  ASSERT_EQ(construct_count__, 0);
+}
+
+TEST(pmr_new, delete$null) {
+  Base *p = nullptr;
   pmr::delete$(p);
+  SUCCEED();
 }

test/pmr/test_pmr_small_storage.cpp

@@ -6,7 +6,7 @@
 
 #include "libpmr/small_storage.h"
 
-TEST(small_storage, holder_construct) {
+TEST(pmr_small_storage, holder_construct) {
   pmr::holder_null();
   pmr::holder<int, true>();
   pmr::holder<int, false>();
@@ -15,7 +15,7 @@ TEST(small_storage, holder_construct) {
   SUCCEED();
 }
 
-TEST(small_storage, holder_copy_move_construct) {
+TEST(pmr_small_storage, holder_copy_move_construct) {
   EXPECT_FALSE(std::is_copy_constructible<pmr::holder_null>::value);
   EXPECT_FALSE((std::is_copy_constructible<pmr::holder<int, true>>::value));
   EXPECT_FALSE((std::is_copy_constructible<pmr::holder<int, false>>::value));
@@ -52,7 +52,7 @@ struct foo {
 
 } // namespace
 
-TEST(small_storage, holder_copy_move_object_stack) {
+TEST(pmr_small_storage, holder_copy_move_object_stack) {
   pmr::allocator alc;
   pmr::holder<foo, true> h1(alc, 1);
   pmr::holder<foo, true> h2, h3;
@@ -67,7 +67,7 @@ TEST(small_storage, holder_copy_move_object_stack) {
   h3.destroy(alc);
 }
 
-TEST(small_storage, holder_copy_move_object_heap) {
+TEST(pmr_small_storage, holder_copy_move_object_heap) {
   pmr::allocator alc;
   pmr::holder<foo, false> h4(alc, 1);
   pmr::holder<foo, false> h5, h6;
@@ -82,7 +82,7 @@ TEST(small_storage, holder_copy_move_object_heap) {
   h6.destroy(alc);
 }
 
-TEST(small_storage, holder_copy_move_array_stack) {
+TEST(pmr_small_storage, holder_copy_move_array_stack) {
   pmr::allocator alc;
   void *ph1 = std::malloc(pmr::holder<void, true>::full_sizeof<int>(10));
   void *ph2 = std::malloc(pmr::holder<void, true>::full_sizeof<int>(10));
@@ -104,7 +104,7 @@ TEST(small_storage, holder_copy_move_array_stack) {
   std::free(ph3);
 }
 
-TEST(small_storage, holder_copy_move_array_heap) {
+TEST(pmr_small_storage, holder_copy_move_array_heap) {
   pmr::allocator alc;
   pmr::holder<void, false> h10(alc, ::LIBIMP::types<int>{}, 10);
   pmr::holder<void, false> h11, h12;
@@ -119,7 +119,7 @@ TEST(small_storage, holder_copy_move_array_heap) {
   h12.destroy(alc);
 }
 
-TEST(small_storage, sizeof) {
+TEST(pmr_small_storage, sizeof) {
   EXPECT_EQ(sizeof(pmr::holder_null), sizeof(void *));
   EXPECT_EQ(sizeof(pmr::holder<int, true>), sizeof(void *) + imp::round_up(sizeof(int), alignof(void *)));
   EXPECT_EQ(sizeof(pmr::holder<int, false>), sizeof(void *) + sizeof(void *));
@@ -133,12 +133,12 @@ TEST(small_storage, sizeof) {
   EXPECT_GT(sizeof(pmr::small_storage<4096>), 4096);
 }
 
-TEST(small_storage, construct) {
+TEST(pmr_small_storage, construct) {
   pmr::small_storage<64> ss;
   SUCCEED();
 }
 
-TEST(small_storage, acquire) {
+TEST(pmr_small_storage, acquire) {
   pmr::small_storage<128> ss;
   pmr::allocator alc;
   ASSERT_FALSE(ss.valid());