[tests] Add test for creation a pool with NULL params

Author: KFilipek

test/CMakeLists.txt

@@ -269,6 +269,10 @@ if(UMF_POOL_SCALABLE_ENABLED AND (NOT UMF_DISABLE_HWLOC))
         NAME scalable_pool
         SRCS pools/scalable_pool.cpp malloc_compliance_tests.cpp
         LIBS ${UMF_UTILS_FOR_TEST} ${UMF_BA_FOR_TEST})
+    add_umf_test(
+        NAME test_pool_null_params
+        SRCS test_pool_null_params.cpp
+        LIBS ${UMF_UTILS_FOR_TEST})
 endif()
 
 if(LINUX AND (NOT UMF_DISABLE_HWLOC)) # OS-specific functions are implemented

test/test_pool_null_params.cpp

@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <gtest/gtest.h>
+#include <umf/memory_pool.h>
+#include <umf/memory_provider.h>
+#include <umf/pools/pool_disjoint.h>
+#include <umf/pools/pool_jemalloc.h>
+#include <umf/pools/pool_proxy.h>
+#include <umf/pools/pool_scalable.h>
+
+// Use correct macro for provider ops version
+#define UMF_MEMORY_PROVIDER_OPS_VERSION_CURRENT UMF_PROVIDER_OPS_VERSION_CURRENT
+
+// Dummy provider implementation for testing
+typedef umf_result_t (*dummy_fn)();
+static umf_result_t dummy_provider_initialize(const void *, void **out) {
+    *out = (void *)0x1;
+    return UMF_RESULT_SUCCESS;
+}
+static umf_result_t dummy_provider_finalize(void *) {
+    return UMF_RESULT_SUCCESS;
+}
+static umf_result_t dummy_alloc(void *, size_t, size_t, void **ptr) {
+    *ptr = malloc(4096);
+    return *ptr ? UMF_RESULT_SUCCESS : UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+}
+static umf_result_t dummy_free(void *, void *, size_t) {
+    return UMF_RESULT_SUCCESS;
+}
+static umf_result_t dummy_get_min_page_size(void *, const void *, size_t *out) {
+    *out = 4096;
+    return UMF_RESULT_SUCCESS;
+}
+static umf_result_t dummy_get_last_native_error(void *, const char **msg,
+                                                int32_t *err) {
+    if (msg) {
+        *msg = "none";
+    }
+    if (err) {
+        *err = 0;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+static umf_result_t dummy_get_recommended_page_size(void *, size_t,
+                                                    size_t *out) {
+    if (out) {
+        *out = 4096;
+    }
+    return UMF_RESULT_SUCCESS;
+}
+static umf_result_t dummy_get_name(void *, const char **out) {
+    if (out) {
+        *out = "dummy";
+    }
+    return UMF_RESULT_SUCCESS;
+}
+
+static umf_memory_provider_ops_t dummy_provider_ops = {
+    UMF_MEMORY_PROVIDER_OPS_VERSION_CURRENT, // version
+    dummy_provider_initialize,               // initialize
+    dummy_provider_finalize,                 // finalize
+    dummy_alloc,                             // alloc
+    dummy_free,                              // free
+    dummy_get_last_native_error,             // get_last_native_error
+    dummy_get_recommended_page_size,         // get_recommended_page_size
+    dummy_get_min_page_size,                 // get_min_page_size
+    dummy_get_name,                          // get_name
+    NULL,                                    // ext_purge_lazy
+    NULL,                                    // ext_purge_force
+    NULL,                                    // ext_allocation_merge
+    NULL,                                    // ext_allocation_split
+    NULL,                                    // ext_get_ipc_handle_size
+    NULL,                                    // ext_get_ipc_handle
+    NULL,                                    // ext_put_ipc_handle
+    NULL,                                    // ext_open_ipc_handle
+    NULL,                                    // ext_close_ipc_handle
+    NULL                                     // ext_ctl
+};
+
+class PoolNullParamsTest : public ::testing::Test {
+  protected:
+    umf_memory_provider_handle_t provider = NULL;
+    void SetUp() override {
+        ASSERT_EQ(umfMemoryProviderCreate(&dummy_provider_ops, NULL, &provider),
+                  UMF_RESULT_SUCCESS);
+    }
+    void TearDown() override {
+        if (provider) {
+            umfMemoryProviderDestroy(provider);
+        }
+    }
+};
+
+TEST_F(PoolNullParamsTest, DisjointPoolNullParams) {
+    umf_memory_pool_handle_t pool;
+    umf_result_t res =
+        umfPoolCreate(umfDisjointPoolOps(), provider, NULL, 0, &pool);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    umfPoolDestroy(pool);
+}
+
+TEST_F(PoolNullParamsTest, ScalablePoolNullParams) {
+    umf_memory_pool_handle_t pool;
+    umf_result_t res =
+        umfPoolCreate(umfScalablePoolOps(), provider, NULL, 0, &pool);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    umfPoolDestroy(pool);
+}
+
+TEST_F(PoolNullParamsTest, JemallocPoolNullParams) {
+#ifdef UMF_POOL_JEMALLOC_ENABLED
+    umf_memory_pool_handle_t pool;
+    umf_result_t res =
+        umfPoolCreate(umfJemallocPoolOps(), provider, NULL, 0, &pool);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    umfPoolDestroy(pool);
+#else
+    GTEST_SKIP() << "Jemalloc pool not enabled, skipping.";
+#endif
+}
+
+TEST_F(PoolNullParamsTest, ProxyPoolNullParams) {
+    umf_memory_pool_handle_t pool;
+    umf_result_t res =
+        umfPoolCreate(umfProxyPoolOps(), provider, NULL, 0, &pool);
+    ASSERT_EQ(res, UMF_RESULT_SUCCESS);
+    umfPoolDestroy(pool);
+}