Add tests for umfPoolCreateFromMemspace()

Signed-off-by: Lukasz Dorau <[email protected]>

Author: ldorau

test/CMakeLists.txt

@@ -165,7 +165,7 @@ if(LINUX) # OS-specific functions are implemented only for Linux now
         LIBS ${UMF_UTILS_FOR_TEST} ${LIBNUMA_LIBRARIES})
     add_umf_test(
         NAME memspace_numa
-        SRCS memspaces/memspace_numa.cpp
+        SRCS memspaces/memspace_numa.cpp malloc_compliance_tests.cpp
         LIBS ${LIBNUMA_LIBRARIES})
     add_umf_test(
         NAME provider_os_memory_config

test/memspaces/memspace_helpers.hpp

@@ -81,6 +81,26 @@ struct memspaceNumaProviderTest : ::memspaceNumaTest {
     umf_memory_provider_handle_t hProvider = nullptr;
 };
 
+struct memspaceNumaPoolTest : ::memspaceNumaTest {
+    void SetUp() override {
+        ::memspaceNumaTest::SetUp();
+
+        umf_result_t ret = umfPoolCreateFromMemspace(hMemspace, nullptr, &pool);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(pool, nullptr);
+    }
+
+    void TearDown() override {
+        ::memspaceNumaTest::TearDown();
+
+        if (pool != nullptr) {
+            umfPoolDestroy(pool);
+        }
+    }
+
+    umf_memory_pool_handle_t pool = nullptr;
+};
+
 struct memspaceHostAllTest : ::numaNodesTest {
     void SetUp() override {
         ::numaNodesTest::SetUp();
@@ -105,10 +125,32 @@ struct memspaceHostAllProviderTest : ::memspaceHostAllTest {
     void TearDown() override {
         ::memspaceHostAllTest::TearDown();
 
-        umfMemoryProviderDestroy(hProvider);
+        if (hProvider != nullptr) {
+            umfMemoryProviderDestroy(hProvider);
+        }
     }
 
     umf_memory_provider_handle_t hProvider = nullptr;
 };
 
+struct memspaceHostAllPoolTest : ::memspaceHostAllTest {
+    void SetUp() override {
+        ::memspaceHostAllTest::SetUp();
+
+        umf_result_t ret = umfPoolCreateFromMemspace(hMemspace, nullptr, &pool);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ASSERT_NE(pool, nullptr);
+    }
+
+    void TearDown() override {
+        ::memspaceHostAllTest::TearDown();
+
+        if (pool != nullptr) {
+            umfPoolDestroy(pool);
+        }
+    }
+
+    umf_memory_pool_handle_t pool = nullptr;
+};
+
 #endif /* UMF_MEMSPACE_HELPERS_HPP */

test/memspaces/memspace_numa.cpp

@@ -4,8 +4,10 @@
 
 #include "memspaces/memspace_numa.h"
 #include "base.hpp"
+#include "malloc_compliance_tests.hpp"
 #include "memspace_helpers.hpp"
 #include "memspace_internal.h"
+#include "pool.hpp"
 
 #include <umf/providers/provider_os_memory.h>
 
@@ -65,3 +67,51 @@ TEST_F(memspaceNumaProviderTest, allocFree) {
     ret = umfMemoryProviderFree(hProvider, ptr, size);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
 }
+
+/* malloc compliance tests of memspaceNumaPoolTest */
+
+TEST_F(memspaceNumaPoolTest, malloc_compliance) {
+    malloc_compliance_test(pool);
+}
+
+TEST_F(memspaceNumaPoolTest, calloc_compliance) {
+    if (!umf_test::isCallocSupported(pool)) {
+        GTEST_SKIP();
+    }
+
+    calloc_compliance_test(pool);
+}
+
+TEST_F(memspaceNumaPoolTest, realloc_compliance) {
+    if (!umf_test::isReallocSupported(pool)) {
+        GTEST_SKIP();
+    }
+
+    realloc_compliance_test(pool);
+}
+
+TEST_F(memspaceNumaPoolTest, free_compliance) { free_compliance_test(pool); }
+
+/* malloc compliance tests of memspaceHostAllPoolTest */
+
+TEST_F(memspaceHostAllPoolTest, malloc_compliance) {
+    malloc_compliance_test(pool);
+}
+
+TEST_F(memspaceHostAllPoolTest, calloc_compliance) {
+    if (!umf_test::isCallocSupported(pool)) {
+        GTEST_SKIP();
+    }
+
+    calloc_compliance_test(pool);
+}
+
+TEST_F(memspaceHostAllPoolTest, realloc_compliance) {
+    if (!umf_test::isReallocSupported(pool)) {
+        GTEST_SKIP();
+    }
+
+    realloc_compliance_test(pool);
+}
+
+TEST_F(memspaceHostAllPoolTest, free_compliance) { free_compliance_test(pool); }