Add tests for jemalloc pool params

Author: vinser52

test/pools/jemalloc_pool.cpp

@@ -42,3 +42,117 @@ TEST_F(test, metadataNotAllocatedUsingProvider) {
             [pool = pool.get()](void *ptr) { umfPoolFree(pool, ptr); });
     }
 }
+
+using jemallocPoolParams = bool;
+struct umfJemallocPoolParamsTest
+    : umf_test::test,
+      ::testing::WithParamInterface<jemallocPoolParams> {
+
+    struct validation_params_t {
+        bool keep_all_memory;
+    };
+
+    struct provider_validator : public umf_test::provider_ba_global {
+        using base_provider = umf_test::provider_ba_global;
+
+        umf_result_t initialize(validation_params_t *params) {
+            EXPECT_NE(params, nullptr);
+            expected_params = params;
+            return UMF_RESULT_SUCCESS;
+        }
+        umf_result_t free(void *ptr, size_t size) {
+            EXPECT_EQ(expected_params->keep_all_memory, false);
+            return base_provider::free(ptr, size);
+        }
+
+        validation_params_t *expected_params;
+    };
+
+    static constexpr umf_memory_provider_ops_t VALIDATOR_PROVIDER_OPS =
+        umf::providerMakeCOps<provider_validator, validation_params_t>();
+
+    umfJemallocPoolParamsTest() : expected_params{false}, params(nullptr) {}
+    void SetUp() override {
+        test::SetUp();
+        expected_params.keep_all_memory = this->GetParam();
+        umf_result_t ret = umfJemallocPoolParamsCreate(&params);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        ret = umfJemallocPoolParamsSetKeepAllMemory(
+            params, expected_params.keep_all_memory);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    void TearDown() override {
+        umfJemallocPoolParamsDestroy(params);
+        test::TearDown();
+    }
+
+    umf::pool_unique_handle_t makePool() {
+        umf_memory_provider_handle_t hProvider = nullptr;
+        umf_memory_pool_handle_t hPool = nullptr;
+
+        auto ret = umfMemoryProviderCreate(&VALIDATOR_PROVIDER_OPS,
+                                           &expected_params, &hProvider);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+        ret = umfPoolCreate(umfJemallocPoolOps(), hProvider, params,
+                            UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+        return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
+    }
+
+    void allocFreeFlow() {
+        static const size_t ALLOC_SIZE = 128;
+        static const size_t NUM_ALLOCATIONS = 100;
+        std::vector<void *> ptrs;
+
+        auto pool = makePool();
+        ASSERT_NE(pool, nullptr);
+
+        for (size_t i = 0; i < NUM_ALLOCATIONS; ++i) {
+            auto *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
+            ASSERT_NE(ptr, nullptr);
+            ptrs.push_back(ptr);
+        }
+
+        for (size_t i = 0; i < NUM_ALLOCATIONS; ++i) {
+            auto ret = umfPoolFree(pool.get(), ptrs[i]);
+            ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+        }
+
+        // Now pool can call free during pool destruction
+        expected_params.keep_all_memory = false;
+    }
+
+    validation_params_t expected_params;
+    umf_jemalloc_pool_params_handle_t params;
+};
+
+TEST_P(umfJemallocPoolParamsTest, allocFree) { allocFreeFlow(); }
+
+TEST_P(umfJemallocPoolParamsTest, updateParams) {
+    expected_params.keep_all_memory = !expected_params.keep_all_memory;
+    umf_result_t ret = umfJemallocPoolParamsSetKeepAllMemory(
+        params, expected_params.keep_all_memory);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    allocFreeFlow();
+}
+
+TEST_P(umfJemallocPoolParamsTest, invalidParams) {
+    umf_result_t ret = umfJemallocPoolParamsCreate(nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfJemallocPoolParamsSetKeepAllMemory(nullptr, true);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfJemallocPoolParamsSetKeepAllMemory(nullptr, false);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    ret = umfJemallocPoolParamsDestroy(nullptr);
+    ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+INSTANTIATE_TEST_SUITE_P(jemallocPoolTest, umfJemallocPoolParamsTest,
+                         testing::Values(false, true));