diff --git a/test/coarse_lib.cpp b/test/coarse_lib.cpp index 41cac1128..880f88dad 100644 --- a/test/coarse_lib.cpp +++ b/test/coarse_lib.cpp @@ -114,7 +114,14 @@ INSTANTIATE_TEST_SUITE_P( CoarseWithMemoryStrategyTest, CoarseWithMemoryStrategyTest, ::testing::Values(UMF_COARSE_MEMORY_STRATEGY_FASTEST, UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE, - UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE)); + UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE), + ([](auto const &info) { + static const char *names[] = { + "UMF_COARSE_MEMORY_STRATEGY_FASTEST", + "UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE", + "UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE"}; + return std::string(names[info.index]); + })); TEST_P(CoarseWithMemoryStrategyTest, coarseTest_basic_provider) { umf_memory_provider_handle_t malloc_memory_provider; diff --git a/test/common/pool.hpp b/test/common/pool.hpp index 5cae85411..b92ddf6d4 100644 --- a/test/common/pool.hpp +++ b/test/common/pool.hpp @@ -25,6 +25,37 @@ #include "provider.hpp" #include "utils/cpp_helpers.hpp" +typedef void *(*pfnPoolParamsCreate)(); +typedef umf_result_t (*pfnPoolParamsDestroy)(void *); + +typedef void *(*pfnProviderParamsCreate)(); +typedef umf_result_t (*pfnProviderParamsDestroy)(void *); + +using poolCreateExtParams = + std::tuple; + +std::string poolCreateExtParamsNameGen( + const testing::TestParamInfo &info) { + + const umf_memory_pool_ops_t *pool_ops = std::get<0>(info.param); + const umf_memory_provider_ops_t *provider_ops = std::get<3>(info.param); + + const char *poolName = NULL; + const char *providerName = NULL; + + pool_ops->get_name(NULL, &poolName); + provider_ops->get_name(NULL, &providerName); + + std::string poolParams = + std::get<1>(info.param) + ? std::string("_w_params_") + std::to_string(info.index) + : std::string(""); + + return std::string(poolName) + poolParams + "_" + providerName; +} + namespace umf_test { umf_memory_pool_handle_t diff --git a/test/common/provider.hpp b/test/common/provider.hpp index 6d42c59f2..00621b311 100644 --- a/test/common/provider.hpp +++ b/test/common/provider.hpp @@ -18,6 +18,36 @@ #include "test_helpers.h" #include "utils/cpp_helpers.hpp" +typedef void *(*pfnProviderParamsCreate)(); +typedef umf_result_t (*pfnProviderParamsDestroy)(void *); + +using providerCreateExtParams = + std::tuple; + +std::string providerCreateExtParamsNameGen( + const testing::TestParamInfo param) { + const umf_memory_provider_ops_t *provider_ops = std::get<0>(param.param); + + const char *providerName = NULL; + provider_ops->get_name(NULL, &providerName); + + return providerName; +} + +void providerCreateExt(providerCreateExtParams params, + umf_test::provider_unique_handle_t *handle) { + umf_memory_provider_handle_t hProvider = nullptr; + auto [provider_ops, provider_params] = params; + + auto ret = + umfMemoryProviderCreate(provider_ops, provider_params, &hProvider); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + ASSERT_NE(hProvider, nullptr); + + *handle = umf_test::provider_unique_handle_t(hProvider, + &umfMemoryProviderDestroy); +} + namespace umf_test { umf_memory_provider_handle_t diff --git a/test/disjoint_pool_file_prov.cpp b/test/disjoint_pool_file_prov.cpp index 607d265e0..98e54b5a7 100644 --- a/test/disjoint_pool_file_prov.cpp +++ b/test/disjoint_pool_file_prov.cpp @@ -37,7 +37,13 @@ INSTANTIATE_TEST_SUITE_P( FileWithMemoryStrategyTest, FileWithMemoryStrategyTest, ::testing::Values(UMF_COARSE_MEMORY_STRATEGY_FASTEST, UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE, - UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE)); + UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE), + ([](auto const &info) { + const char *names[] = {"UMF_COARSE_MEMORY_STRATEGY_FASTEST", + "UMF_COARSE_MEMORY_STRATEGY_FASTEST_BUT_ONE", + "UMF_COARSE_MEMORY_STRATEGY_CHECK_ALL_SIZE"}; + return std::string(names[info.index]); + })); TEST_P(FileWithMemoryStrategyTest, disjointFileMallocPool_simple1) { umf_memory_provider_handle_t malloc_memory_provider = nullptr; diff --git a/test/ipcAPI.cpp b/test/ipcAPI.cpp index bd3f412da..c9496f863 100644 --- a/test/ipcAPI.cpp +++ b/test/ipcAPI.cpp @@ -128,4 +128,5 @@ INSTANTIATE_TEST_SUITE_P(umfIpcTestSuite, umfIpcTest, ::testing::Values(ipcTestParams{ umfProxyPoolOps(), nullptr, nullptr, &IPC_MOCK_PROVIDER_OPS, nullptr, nullptr, - &hostMemoryAccessor})); + &hostMemoryAccessor}), + ipcTestParamsNameGen); diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp index 4c1e5e714..0a23777bb 100644 --- a/test/ipcFixtures.hpp +++ b/test/ipcFixtures.hpp @@ -5,21 +5,21 @@ #ifndef UMF_TEST_IPC_FIXTURES_HPP #define UMF_TEST_IPC_FIXTURES_HPP -#include "base.hpp" -#include "multithread_helpers.hpp" -#include "pool.hpp" -#include "test_helpers.h" +#include +#include +#include +#include +#include #include #include #include #include -#include -#include -#include -#include -#include +#include "base.hpp" +#include "multithread_helpers.hpp" +#include "pool.hpp" +#include "test_helpers.h" class MemoryAccessor { public: @@ -27,6 +27,7 @@ class MemoryAccessor { virtual void fill(void *ptr, size_t size, const void *pattern, size_t pattern_size) = 0; virtual void copy(void *dst_ptr, void *src_ptr, size_t size) = 0; + virtual const char *getName() = 0; }; class HostMemoryAccessor : public MemoryAccessor { @@ -47,6 +48,8 @@ class HostMemoryAccessor : public MemoryAccessor { void copy(void *dst_ptr, void *src_ptr, size_t size) override { std::memcpy(dst_ptr, src_ptr, size); } + + const char *getName() override { return "HostMemoryAccessor"; } }; typedef void *(*pfnPoolParamsCreate)(); @@ -65,6 +68,28 @@ using ipcTestParams = pfnProviderParamsCreate, pfnProviderParamsDestroy, MemoryAccessor *>; +std::string +ipcTestParamsNameGen(const ::testing::TestParamInfo &info) { + const umf_memory_pool_ops_t *pool_ops = std::get<0>(info.param); + const umf_memory_provider_ops_t *provider_ops = std::get<3>(info.param); + + const char *poolName = NULL; + const char *providerName = NULL; + + pool_ops->get_name(NULL, &poolName); + provider_ops->get_name(NULL, &providerName); + + std::string poolParams = + std::get<1>(info.param) + ? std::string("_w_params_") + std::to_string(info.index) + : std::string(""); + + MemoryAccessor *memAccessor = std::get<6>(info.param); + + return std::string(poolName) + poolParams + "_" + providerName + "_" + + memAccessor->getName(); +} + struct umfIpcTest : umf_test::test, ::testing::WithParamInterface { umfIpcTest() {} diff --git a/test/memoryPoolAPI.cpp b/test/memoryPoolAPI.cpp index 16d7afd58..2170c7a29 100644 --- a/test/memoryPoolAPI.cpp +++ b/test/memoryPoolAPI.cpp @@ -3,13 +3,12 @@ // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // This file contains tests for UMF pool API -#include "base.hpp" -#include "pool.hpp" -#include "poolFixtures.hpp" -#include "provider.hpp" -#include "provider_null.h" -#include "provider_trace.h" -#include "test_helpers.h" +#include +#include +#include +#include +#include +#include #include #include @@ -19,12 +18,13 @@ #include #endif -#include -#include -#include -#include -#include -#include +#include "base.hpp" +#include "pool.hpp" +#include "poolFixtures.hpp" +#include "provider.hpp" +#include "provider_null.h" +#include "provider_trace.h" +#include "test_helpers.h" using umf_test::test; using namespace umf_test; @@ -309,16 +309,23 @@ INSTANTIATE_TEST_SUITE_P( &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}, poolCreateExtParams{umfDisjointPoolOps(), defaultDisjointPoolConfig, defaultDisjointPoolConfigDestroy, - &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr})); + &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}), + poolCreateExtParamsNameGen); INSTANTIATE_TEST_SUITE_P(mallocMultiPoolTest, umfMultiPoolTest, ::testing::Values(poolCreateExtParams{ umfProxyPoolOps(), nullptr, nullptr, - &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr})); + &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}), + poolCreateExtParamsNameGen); INSTANTIATE_TEST_SUITE_P(umfPoolWithCreateFlagsTest, umfPoolWithCreateFlagsTest, ::testing::Values(0, - UMF_POOL_CREATE_FLAG_OWN_PROVIDER)); + UMF_POOL_CREATE_FLAG_OWN_PROVIDER), + ([](auto const &info) { + static const char *names[] = { + "NONE", "UMF_POOL_CREATE_FLAG_OWN_PROVIDER"}; + return std::string(names[info.index]); + })); ////////////////// Negative test cases ///////////////// @@ -382,7 +389,14 @@ INSTANTIATE_TEST_SUITE_P( ::testing::Values(UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC, UMF_RESULT_ERROR_INVALID_ARGUMENT, - UMF_RESULT_ERROR_UNKNOWN)); + UMF_RESULT_ERROR_UNKNOWN), + ([](auto const &info) { + static const char *names[] = { + "UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY", + "UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC", + "UMF_RESULT_ERROR_INVALID_ARGUMENT", "UMF_RESULT_ERROR_UNKNOWN"}; + return names[info.index]; + })); TEST_P(poolInitializeTest, errorPropagation) { auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate()); @@ -559,4 +573,19 @@ INSTANTIATE_TEST_SUITE_P( umf_test::withGeneratedArgs(umfPoolGetMemoryProvider), umf_test::withGeneratedArgs(umfPoolByPtr), umf_test::withGeneratedArgs(umfPoolSetTag), - umf_test::withGeneratedArgs(umfPoolGetTag))); + umf_test::withGeneratedArgs(umfPoolGetTag)), + ([](auto const &info) { + static const char *names[] = {"umfPoolMalloc", + "umfPoolAlignedMalloc", + "umfPoolFree", + "umfPoolCalloc", + "umfPoolRealloc", + "umfPoolMallocUsableSize", + "umfPoolGetLastAllocationError", + "umfPoolGetName", + "umfPoolGetMemoryProvider", + "umfPoolByPtr", + "umfPoolSetTag", + "umfPoolGetTag"}; + return std::string(names[info.index]); + })); diff --git a/test/memoryProviderAPI.cpp b/test/memoryProviderAPI.cpp index 33e298dc6..7d57e6fda 100644 --- a/test/memoryProviderAPI.cpp +++ b/test/memoryProviderAPI.cpp @@ -338,7 +338,14 @@ INSTANTIATE_TEST_SUITE_P( ::testing::Values(UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC, UMF_RESULT_ERROR_INVALID_ARGUMENT, - UMF_RESULT_ERROR_UNKNOWN)); + UMF_RESULT_ERROR_UNKNOWN), + ([](auto const &info) { + static const char *names[] = { + "UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY", + "UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC", + "UMF_RESULT_ERROR_INVALID_ARGUMENT", "UMF_RESULT_ERROR_UNKNOWN"}; + return std::string(names[info.index]); + })); TEST_P(providerInitializeTest, errorPropagation) { struct provider : public umf_test::provider_base_t { @@ -389,4 +396,14 @@ INSTANTIATE_TEST_SUITE_P( umf_test::withGeneratedArgs(umfMemoryProviderGetMinPageSize), umf_test::withGeneratedArgs(umfMemoryProviderPurgeLazy), umf_test::withGeneratedArgs(umfMemoryProviderPurgeForce), - umf_test::withGeneratedArgs(umfMemoryProviderGetName))); + umf_test::withGeneratedArgs(umfMemoryProviderGetName)), + ([](auto const &info) { + static const char *names[] = {"umfMemoryProviderAlloc", + "umfMemoryProviderFree", + "umfMemoryProviderGetRecommendedPageSize", + "umfMemoryProviderGetMinPageSize", + "umfMemoryProviderPurgeLazy", + "umfMemoryProviderPurgeForce", + "umfMemoryProviderGetName"}; + return std::string(names[info.index]); + })); diff --git a/test/memspaces/memspace_highest_bandwidth.cpp b/test/memspaces/memspace_highest_bandwidth.cpp index 5bedac0ea..b1d56208a 100644 --- a/test/memspaces/memspace_highest_bandwidth.cpp +++ b/test/memspaces/memspace_highest_bandwidth.cpp @@ -40,16 +40,25 @@ static void canQueryBandwidth(size_t nodeId) { } } -INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyTest, memspaceGetTest, - ::testing::Values(memspaceGetParams{ - canQueryBandwidth, - umfMemspaceHighestBandwidthGet})); - -INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyProviderTest, - memspaceProviderTest, - ::testing::Values(memspaceGetParams{ - canQueryBandwidth, - umfMemspaceHighestBandwidthGet})); +INSTANTIATE_TEST_SUITE_P( + memspaceLowestLatencyTest, memspaceGetTest, + ::testing::Values(memspaceGetParams{canQueryBandwidth, + umfMemspaceHighestBandwidthGet}), + ([](auto const &info) { + static const char *names[] = {"canQueryBandwidth", + "umfMemspaceHighestBandwidthGet"}; + return std::string(names[info.index]); + })); + +INSTANTIATE_TEST_SUITE_P( + memspaceLowestLatencyProviderTest, memspaceProviderTest, + ::testing::Values(memspaceGetParams{canQueryBandwidth, + umfMemspaceHighestBandwidthGet}), + ([](auto const &info) { + static const char *names[] = {"canQueryBandwidth", + "umfMemspaceHighestBandwidthGet"}; + return std::string(names[info.index]); + })); TEST_F(numaNodesTest, PerCoreBandwidthPlacement) { const size_t allocSize = 4096; diff --git a/test/memspaces/memspace_lowest_latency.cpp b/test/memspaces/memspace_lowest_latency.cpp index 02fdd481e..e84e3a8f3 100644 --- a/test/memspaces/memspace_lowest_latency.cpp +++ b/test/memspaces/memspace_lowest_latency.cpp @@ -41,9 +41,21 @@ static void canQueryLatency(size_t nodeId) { INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyTest, memspaceGetTest, ::testing::Values(memspaceGetParams{ - canQueryLatency, umfMemspaceLowestLatencyGet})); + canQueryLatency, umfMemspaceLowestLatencyGet}), + ([](auto const &info) { + static const char *names[] = { + "canQueryLatency", + "umfMemspaceLowestLatencyGet"}; + return std::string(names[info.index]); + })); INSTANTIATE_TEST_SUITE_P(memspaceLowestLatencyProviderTest, memspaceProviderTest, ::testing::Values(memspaceGetParams{ - canQueryLatency, umfMemspaceLowestLatencyGet})); + canQueryLatency, umfMemspaceLowestLatencyGet}), + ([](auto const &info) { + static const char *names[] = { + "canQueryLatency", + "umfMemspaceLowestLatencyGet"}; + return std::string(names[info.index]); + })); diff --git a/test/poolFixtures.hpp b/test/poolFixtures.hpp index 633ebba43..f17f5b31e 100644 --- a/test/poolFixtures.hpp +++ b/test/poolFixtures.hpp @@ -23,17 +23,6 @@ #include "provider.hpp" #include "utils/utils_sanitizers.h" -typedef void *(*pfnPoolParamsCreate)(); -typedef umf_result_t (*pfnPoolParamsDestroy)(void *); - -typedef void *(*pfnProviderParamsCreate)(); -typedef umf_result_t (*pfnProviderParamsDestroy)(void *); - -using poolCreateExtParams = - std::tuple; - umf_test::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) { auto [pool_ops, poolParamsCreate, poolParamsDestroy, provider_ops, providerParamsCreate, providerParamsDestroy] = params; diff --git a/test/pools/disjoint_pool.cpp b/test/pools/disjoint_pool.cpp index 92ccd0410..5497cd568 100644 --- a/test/pools/disjoint_pool.cpp +++ b/test/pools/disjoint_pool.cpp @@ -499,7 +499,8 @@ INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfPoolTest, ::testing::Values(poolCreateExtParams{ umfDisjointPoolOps(), defaultDisjointPoolConfig, defaultDisjointPoolConfigDestroy, - &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr})); + &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}), + poolCreateExtParamsNameGen); void *memProviderParams() { return (void *)&DEFAULT_DISJOINT_CAPACITY; } @@ -510,10 +511,15 @@ INSTANTIATE_TEST_SUITE_P( defaultDisjointPoolConfigDestroy, &MOCK_OUT_OF_MEM_PROVIDER_OPS, memProviderParams, nullptr}, - static_cast(DEFAULT_DISJOINT_CAPACITY) / 2))); + static_cast(DEFAULT_DISJOINT_CAPACITY) / 2)), + ([](auto) { + return std::string("disjoint_out_of_mem_capacity_") + + std::to_string(static_cast(DEFAULT_DISJOINT_CAPACITY) / 2); + })); INSTANTIATE_TEST_SUITE_P(disjointMultiPoolTests, umfMultiPoolTest, ::testing::Values(poolCreateExtParams{ umfDisjointPoolOps(), defaultDisjointPoolConfig, defaultDisjointPoolConfigDestroy, - &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr})); + &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}), + poolCreateExtParamsNameGen); diff --git a/test/pools/jemalloc_coarse_devdax.cpp b/test/pools/jemalloc_coarse_devdax.cpp index 703f1176b..8f96739ae 100644 --- a/test/pools/jemalloc_coarse_devdax.cpp +++ b/test/pools/jemalloc_coarse_devdax.cpp @@ -41,4 +41,5 @@ static std::vector poolParamsList = : std::vector{}; INSTANTIATE_TEST_SUITE_P(jemallocCoarseDevDaxTest, umfPoolTest, - ::testing::ValuesIn(poolParamsList)); + ::testing::ValuesIn(poolParamsList), + poolCreateExtParamsNameGen); diff --git a/test/pools/jemalloc_coarse_file.cpp b/test/pools/jemalloc_coarse_file.cpp index bce595a2b..b6f84804f 100644 --- a/test/pools/jemalloc_coarse_file.cpp +++ b/test/pools/jemalloc_coarse_file.cpp @@ -28,4 +28,5 @@ INSTANTIATE_TEST_SUITE_P(jemallocCoarseFileTest, umfPoolTest, ::testing::Values(poolCreateExtParams{ umfJemallocPoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(), getFileParamsDefault, - destroyFileParams})); + destroyFileParams}), + poolCreateExtParamsNameGen); diff --git a/test/pools/jemalloc_pool.cpp b/test/pools/jemalloc_pool.cpp index 97a2128f7..c0cf202f0 100644 --- a/test/pools/jemalloc_pool.cpp +++ b/test/pools/jemalloc_pool.cpp @@ -87,7 +87,8 @@ INSTANTIATE_TEST_SUITE_P( poolCreateExtParams{umfJemallocPoolOps(), createJemallocParams<1>, destroyJemallocParams, umfOsMemoryProviderOps(), createOsMemoryProviderParams, - destroyOsMemoryProviderParams})); + destroyOsMemoryProviderParams}), + poolCreateExtParamsNameGen); // this test makes sure that jemalloc does not use // memory provider to allocate metadata (and hence diff --git a/test/pools/pool_base_alloc.cpp b/test/pools/pool_base_alloc.cpp index 4be438936..8819a01d2 100644 --- a/test/pools/pool_base_alloc.cpp +++ b/test/pools/pool_base_alloc.cpp @@ -7,12 +7,11 @@ #include #include +#include "base_alloc_global.h" #include "pool.hpp" #include "poolFixtures.hpp" #include "provider.hpp" -#include "base_alloc_global.h" - struct base_alloc_pool : public umf_test::pool_base_t { void *malloc(size_t size) noexcept { return umf_ba_global_alloc(size); } @@ -58,4 +57,5 @@ umf_memory_pool_ops_t BA_POOL_OPS = INSTANTIATE_TEST_SUITE_P(baPool, umfPoolTest, ::testing::Values(poolCreateExtParams{ &BA_POOL_OPS, nullptr, nullptr, - &umf_test::BASE_PROVIDER_OPS, nullptr, nullptr})); + &umf_test::BASE_PROVIDER_OPS, nullptr, nullptr}), + poolCreateExtParamsNameGen); diff --git a/test/pools/scalable_coarse_devdax.cpp b/test/pools/scalable_coarse_devdax.cpp index 8dc8d576b..6e27cd909 100644 --- a/test/pools/scalable_coarse_devdax.cpp +++ b/test/pools/scalable_coarse_devdax.cpp @@ -45,4 +45,5 @@ static std::vector poolParamsList = : std::vector{}; INSTANTIATE_TEST_SUITE_P(scalableCoarseDevDaxTest, umfPoolTest, - ::testing::ValuesIn(poolParamsList)); + ::testing::ValuesIn(poolParamsList), + poolCreateExtParamsNameGen); diff --git a/test/pools/scalable_coarse_file.cpp b/test/pools/scalable_coarse_file.cpp index b9865b781..778a47202 100644 --- a/test/pools/scalable_coarse_file.cpp +++ b/test/pools/scalable_coarse_file.cpp @@ -28,4 +28,5 @@ INSTANTIATE_TEST_SUITE_P(scalableCoarseFileTest, umfPoolTest, ::testing::Values(poolCreateExtParams{ umfScalablePoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(), getFileParamsDefault, - destroyFileParams})); + destroyFileParams}), + poolCreateExtParamsNameGen); diff --git a/test/pools/scalable_pool.cpp b/test/pools/scalable_pool.cpp index 0c6830201..cf951b6ee 100644 --- a/test/pools/scalable_pool.cpp +++ b/test/pools/scalable_pool.cpp @@ -28,7 +28,8 @@ INSTANTIATE_TEST_SUITE_P( scalablePoolTest, umfPoolTest, ::testing::Values(poolCreateExtParams{ umfScalablePoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(), - createOsMemoryProviderParams, destroyOsMemoryProviderParams})); + createOsMemoryProviderParams, destroyOsMemoryProviderParams}), + poolCreateExtParamsNameGen); using scalablePoolParams = std::tuple; struct umfScalablePoolParamsTest @@ -165,7 +166,13 @@ INSTANTIATE_TEST_SUITE_P( scalablePoolTest, umfScalablePoolParamsTest, testing::Combine(testing::Values(2 * 1024 * 1024, 3 * 1024 * 1024, 4 * 1024 * 1024, 5 * 1024 * 1024), - testing::Values(false, true))); + testing::Values(false, true)), + ([](auto const &info) { + return std::string("scalable_granularity_") + + std::to_string(std::get<0>(info.param)) + + std::string("_keep_all_memory") + + (std::get<1>(info.param) ? "_true" : "_false"); + })); TEST(scalablePoolTest, scalablePoolName) { umf_memory_pool_handle_t pool = nullptr; diff --git a/test/provider_devdax_memory.cpp b/test/provider_devdax_memory.cpp index a951ca08e..07d64325a 100644 --- a/test/provider_devdax_memory.cpp +++ b/test/provider_devdax_memory.cpp @@ -3,19 +3,21 @@ // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception #ifndef _WIN32 -#include "test_helpers_linux.h" #include #include #include #endif -#include "base.hpp" +#include +#include +#include "base.hpp" +#include "provider.hpp" #include "test_helpers.h" #include "utils/cpp_helpers.hpp" - -#include -#include +#ifndef _WIN32 +#include "test_helpers_linux.h" +#endif using umf_test::test; @@ -43,23 +45,6 @@ static int compare_native_error_str(const char *message, int error) { return strncmp(message, error_str, len); } -using providerCreateExtParams = - std::tuple; - -static void providerCreateExt(providerCreateExtParams params, - umf_test::provider_unique_handle_t *handle) { - umf_memory_provider_handle_t hProvider = nullptr; - auto [provider_ops, provider_params] = params; - - auto ret = - umfMemoryProviderCreate(provider_ops, provider_params, &hProvider); - ASSERT_EQ(ret, UMF_RESULT_SUCCESS); - ASSERT_NE(hProvider, nullptr); - - *handle = umf_test::provider_unique_handle_t(hProvider, - &umfMemoryProviderDestroy); -} - struct umfProviderTest : umf_test::test, ::testing::WithParamInterface { @@ -211,7 +196,8 @@ static std::vector devdaxProviderTestParamsList = GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfProviderTest); INSTANTIATE_TEST_SUITE_P(devdaxProviderTest, umfProviderTest, - ::testing::ValuesIn(devdaxProviderTestParamsList)); + ::testing::ValuesIn(devdaxProviderTestParamsList), + providerCreateExtParamsNameGen); TEST_P(umfProviderTest, create_destroy) {} diff --git a/test/provider_devdax_memory_ipc.cpp b/test/provider_devdax_memory_ipc.cpp index d88b1f005..dd9452e54 100644 --- a/test/provider_devdax_memory_ipc.cpp +++ b/test/provider_devdax_memory_ipc.cpp @@ -77,4 +77,5 @@ static std::vector getIpcProxyPoolTestParamsList(void) { GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest); INSTANTIATE_TEST_SUITE_P(DevDaxProviderDifferentPoolsTest, umfIpcTest, - ::testing::ValuesIn(getIpcProxyPoolTestParamsList())); + ::testing::ValuesIn(getIpcProxyPoolTestParamsList()), + ipcTestParamsNameGen); diff --git a/test/provider_file_memory.cpp b/test/provider_file_memory.cpp index 6252745c6..055b4c613 100644 --- a/test/provider_file_memory.cpp +++ b/test/provider_file_memory.cpp @@ -2,17 +2,17 @@ // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -#include "base.hpp" +#include +#include +#include "base.hpp" +#include "provider.hpp" #include "test_helpers.h" #include "utils/cpp_helpers.hpp" #ifndef _WIN32 #include "test_helpers_linux.h" #endif -#include -#include - using umf_test::test; #define FILE_PATH ((char *)"tmp_file") @@ -39,23 +39,6 @@ static int compare_native_error_str(const char *message, int error) { return strncmp(message, error_str, len); } -using providerCreateExtParams = - std::tuple; - -static void providerCreateExt(providerCreateExtParams params, - umf_test::provider_unique_handle_t *handle) { - umf_memory_provider_handle_t hProvider = nullptr; - auto [provider_ops, provider_params] = params; - - auto ret = - umfMemoryProviderCreate(provider_ops, provider_params, &hProvider); - ASSERT_EQ(ret, UMF_RESULT_SUCCESS); - ASSERT_NE(hProvider, nullptr); - - *handle = umf_test::provider_unique_handle_t(hProvider, - &umfMemoryProviderDestroy); -} - struct FileProviderParamsDefault : umf_test::test, ::testing::WithParamInterface { @@ -218,7 +201,8 @@ file_params_unique_handle_t file_params_shared = INSTANTIATE_TEST_SUITE_P(fileProviderTest, FileProviderParamsDefault, ::testing::Values(providerCreateExtParams{ umfFileMemoryProviderOps(), - file_params_default.get()})); + file_params_default.get()}), + providerCreateExtParamsNameGen); TEST_P(FileProviderParamsDefault, create_destroy) {} @@ -478,7 +462,8 @@ TEST_P(FileProviderParamsDefault, purge_force_INVALID_POINTER) { INSTANTIATE_TEST_SUITE_P(fileProviderTest, FileProviderParamsShared, ::testing::Values(providerCreateExtParams{ umfFileMemoryProviderOps(), - file_params_shared.get()})); + file_params_shared.get()}), + providerCreateExtParamsNameGen); TEST_P(FileProviderParamsShared, IPC_base_success_test) { umf_result_t umf_result; diff --git a/test/provider_file_memory_ipc.cpp b/test/provider_file_memory_ipc.cpp index b749772f4..786487644 100644 --- a/test/provider_file_memory_ipc.cpp +++ b/test/provider_file_memory_ipc.cpp @@ -140,7 +140,9 @@ static std::vector getIpcFsDaxTestParamsList(void) { GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest); INSTANTIATE_TEST_SUITE_P(FileProviderDifferentPoolsTest, umfIpcTest, - ::testing::ValuesIn(ipcManyPoolsTestParamsList)); + ::testing::ValuesIn(ipcManyPoolsTestParamsList), + ipcTestParamsNameGen); INSTANTIATE_TEST_SUITE_P(FileProviderDifferentPoolsFSDAXTest, umfIpcTest, - ::testing::ValuesIn(getIpcFsDaxTestParamsList())); + ::testing::ValuesIn(getIpcFsDaxTestParamsList()), + ipcTestParamsNameGen); diff --git a/test/provider_fixed_memory.cpp b/test/provider_fixed_memory.cpp index bfdcd9fc2..fdca92274 100644 --- a/test/provider_fixed_memory.cpp +++ b/test/provider_fixed_memory.cpp @@ -2,18 +2,18 @@ // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -#include "base.hpp" +#include +#include +#include +#include "base.hpp" +#include "provider.hpp" #include "test_helpers.h" #include "utils/cpp_helpers.hpp" #ifndef _WIN32 #include "test_helpers_linux.h" #endif -#include -#include -#include - using umf_test::test; #define FIXED_BUFFER_SIZE (10 * utils_get_page_size()) @@ -38,23 +38,6 @@ static int compare_native_error_str(const char *message, int error) { return strncmp(message, error_str, len); } -using providerCreateExtParams = - std::tuple; - -static void providerCreateExt(providerCreateExtParams params, - umf_test::provider_unique_handle_t *handle) { - umf_memory_provider_handle_t hProvider = nullptr; - auto [provider_ops, provider_params] = params; - - auto ret = - umfMemoryProviderCreate(provider_ops, provider_params, &hProvider); - ASSERT_EQ(ret, UMF_RESULT_SUCCESS); - ASSERT_NE(hProvider, nullptr); - - *handle = umf_test::provider_unique_handle_t(hProvider, - &umfMemoryProviderDestroy); -} - struct FixedProviderTest : umf_test::test, ::testing::WithParamInterface { @@ -154,7 +137,8 @@ struct FixedProviderTest INSTANTIATE_TEST_SUITE_P(fixedProviderTest, FixedProviderTest, ::testing::Values(providerCreateExtParams{ - umfFixedMemoryProviderOps(), nullptr})); + umfFixedMemoryProviderOps(), nullptr}), + providerCreateExtParamsNameGen); TEST_P(FixedProviderTest, create_destroy) { // Creation and destruction are handled in SetUp and TearDown diff --git a/test/provider_os_memory.cpp b/test/provider_os_memory.cpp index 02a20df2f..d2eb340a3 100644 --- a/test/provider_os_memory.cpp +++ b/test/provider_os_memory.cpp @@ -2,12 +2,6 @@ // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -#include "base.hpp" - -#include "ipcFixtures.hpp" -#include "test_helpers.h" -#include "utils/cpp_helpers.hpp" - #include #include #include @@ -15,6 +9,12 @@ #include #endif +#include "base.hpp" +#include "ipcFixtures.hpp" +#include "provider.hpp" +#include "test_helpers.h" +#include "utils/cpp_helpers.hpp" + using umf_test::test; #define INVALID_PTR ((void *)0x01) @@ -44,23 +44,6 @@ static int compare_native_error_str(const char *message, int error) { return strncmp(message, error_str, len); } -using providerCreateExtParams = - std::tuple; - -static void providerCreateExt(providerCreateExtParams params, - umf_test::provider_unique_handle_t *handle) { - umf_memory_provider_handle_t hProvider = nullptr; - auto [provider_ops, provider_params] = params; - - auto ret = - umfMemoryProviderCreate(provider_ops, provider_params, &hProvider); - ASSERT_EQ(ret, UMF_RESULT_SUCCESS); - ASSERT_NE(hProvider, nullptr); - - *handle = umf_test::provider_unique_handle_t(hProvider, - &umfMemoryProviderDestroy); -} - struct umfProviderTest : umf_test::test, ::testing::WithParamInterface { @@ -247,7 +230,8 @@ auto defaultParams = createOsMemoryProviderParams(); INSTANTIATE_TEST_SUITE_P(osProviderTest, umfProviderTest, ::testing::Values(providerCreateExtParams{ - umfOsMemoryProviderOps(), defaultParams.get()})); + umfOsMemoryProviderOps(), defaultParams.get()}), + providerCreateExtParamsNameGen); TEST_P(umfProviderTest, create_destroy) {} @@ -504,4 +488,5 @@ static std::vector ipcTestParamsList = { }; INSTANTIATE_TEST_SUITE_P(osProviderTest, umfIpcTest, - ::testing::ValuesIn(ipcTestParamsList)); + ::testing::ValuesIn(ipcTestParamsList), + ipcTestParamsNameGen); diff --git a/test/provider_os_memory_config.cpp b/test/provider_os_memory_config.cpp index ed3456618..3278253a9 100644 --- a/test/provider_os_memory_config.cpp +++ b/test/provider_os_memory_config.cpp @@ -1,20 +1,20 @@ /* * - * Copyright (C) 2024 Intel Corporation + * 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 +#include + #include "base.hpp" #include #include -#include -#include - static constexpr size_t allocSize = 4096; struct providerConfigTest : testing::Test { @@ -238,11 +238,17 @@ struct providerConfigTestNumaMode } }; -INSTANTIATE_TEST_SUITE_P(numa_modes, providerConfigTestNumaMode, - testing::Values(UMF_NUMA_MODE_DEFAULT, - UMF_NUMA_MODE_BIND, - UMF_NUMA_MODE_INTERLEAVE, - UMF_NUMA_MODE_LOCAL)); +INSTANTIATE_TEST_SUITE_P( + numa_modes, providerConfigTestNumaMode, + testing::Values(UMF_NUMA_MODE_DEFAULT, UMF_NUMA_MODE_BIND, + UMF_NUMA_MODE_INTERLEAVE, UMF_NUMA_MODE_LOCAL), + ([](auto const &info) { + static const char *names[] = { + "UMF_NUMA_MODE_DEFAULT", "UMF_NUMA_MODE_BIND", + "UMF_NUMA_MODE_INTERLEAVE", "UMF_NUMA_MODE_LOCAL"}; + return std::string(names[info.index]); + })); + #ifndef MPOL_LOCAL #define MPOL_LOCAL 4 #endif diff --git a/test/provider_os_memory_multiple_numa_nodes.cpp b/test/provider_os_memory_multiple_numa_nodes.cpp index cfc58f2f0..4d8e182c9 100644 --- a/test/provider_os_memory_multiple_numa_nodes.cpp +++ b/test/provider_os_memory_multiple_numa_nodes.cpp @@ -1,11 +1,7 @@ -// Copyright (C) 2024 Intel Corporation +// 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 "base.hpp" -#include "numa_helpers.hpp" -#include "test_helpers.h" - #include #include #include @@ -14,6 +10,10 @@ #include +#include "base.hpp" +#include "numa_helpers.hpp" +#include "test_helpers.h" + std::vector get_available_numa_nodes() { if (numa_available() == -1 || numa_all_nodes_ptr == nullptr) { return std::vector(); @@ -147,7 +147,11 @@ using the macro) GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(testNumaOnEachNode); INSTANTIATE_TEST_SUITE_P(testNumaNodesAllocations, testNumaOnEachNode, - ::testing::ValuesIn(get_available_numa_nodes())); + ::testing::ValuesIn(get_available_numa_nodes()), + ([](auto const &info) { + return std::string("numa_") + + std::to_string(info.param); + })); // Test for allocations on numa nodes. It will be executed on each of // the available numa nodes. @@ -293,7 +297,11 @@ struct testNumaOnEachCpu : testNuma, testing::WithParamInterface { }; INSTANTIATE_TEST_SUITE_P(testNumaNodesAllocationsAllCpus, testNumaOnEachCpu, - ::testing::ValuesIn(get_available_cpus())); + ::testing::ValuesIn(get_available_cpus()), + ([](auto const &info) { + return std::string("cpu_") + + std::to_string(info.param); + })); // Test for allocation on numa node with mode preferred and an empty nodeset. // For the empty nodeset the memory is allocated on the node of the CPU that diff --git a/test/provider_tracking.cpp b/test/provider_tracking.cpp index db186e15f..52d5eeb8f 100644 --- a/test/provider_tracking.cpp +++ b/test/provider_tracking.cpp @@ -2,40 +2,23 @@ // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -#include "base.hpp" +#include +#include +#include +#include "base.hpp" +#include "provider.hpp" #include "test_helpers.h" #include "utils/cpp_helpers.hpp" #ifndef _WIN32 #include "test_helpers_linux.h" #endif -#include -#include -#include - using umf_test::test; #define FIXED_BUFFER_SIZE (512 * utils_get_page_size()) #define INVALID_PTR ((void *)0x01) -using providerCreateExtParams = - std::tuple; - -static void providerCreateExt(providerCreateExtParams params, - umf_test::provider_unique_handle_t *handle) { - umf_memory_provider_handle_t hProvider = nullptr; - auto [provider_ops, provider_params] = params; - - auto ret = - umfMemoryProviderCreate(provider_ops, provider_params, &hProvider); - ASSERT_EQ(ret, UMF_RESULT_SUCCESS); - ASSERT_NE(hProvider, nullptr); - - *handle = umf_test::provider_unique_handle_t(hProvider, - &umfMemoryProviderDestroy); -} - struct TrackingProviderTest : umf_test::test, ::testing::WithParamInterface { @@ -121,7 +104,8 @@ createPoolFromAllocation(void *ptr0, size_t size1, INSTANTIATE_TEST_SUITE_P(trackingProviderTest, TrackingProviderTest, ::testing::Values(providerCreateExtParams{ - umfFixedMemoryProviderOps(), nullptr})); + umfFixedMemoryProviderOps(), nullptr}), + providerCreateExtParamsNameGen); TEST_P(TrackingProviderTest, create_destroy) { // Creation and destruction are handled in SetUp and TearDown diff --git a/test/provider_tracking_fixture_tests.cpp b/test/provider_tracking_fixture_tests.cpp index 51dbc07c1..4d40bf96c 100644 --- a/test/provider_tracking_fixture_tests.cpp +++ b/test/provider_tracking_fixture_tests.cpp @@ -86,10 +86,12 @@ INSTANTIATE_TEST_SUITE_P(TrackingProviderPoolTest, umfPoolTest, ::testing::Values(poolCreateExtParams{ umfProxyPoolOps(), nullptr, nullptr, &PROVIDER_FROM_POOL_OPS, - providerFromPoolParamsCreate, nullptr})); + providerFromPoolParamsCreate, nullptr}), + poolCreateExtParamsNameGen); INSTANTIATE_TEST_SUITE_P(TrackingProviderMultiPoolTest, umfMultiPoolTest, ::testing::Values(poolCreateExtParams{ umfProxyPoolOps(), nullptr, nullptr, &PROVIDER_FROM_POOL_OPS, - providerFromPoolParamsCreate, nullptr})); + providerFromPoolParamsCreate, nullptr}), + poolCreateExtParamsNameGen); diff --git a/test/providers/provider_cuda.cpp b/test/providers/provider_cuda.cpp index 9b0d29f4b..7901b21b0 100644 --- a/test/providers/provider_cuda.cpp +++ b/test/providers/provider_cuda.cpp @@ -106,7 +106,7 @@ class CUDAMemoryAccessor : public MemoryAccessor { : hDevice_(hDevice), hContext_(hContext) {} void fill(void *ptr, size_t size, const void *pattern, - size_t pattern_size) { + size_t pattern_size) override { ASSERT_NE(hContext_, nullptr); ASSERT_GE(hDevice_, -1); ASSERT_NE(ptr, nullptr); @@ -116,7 +116,7 @@ class CUDAMemoryAccessor : public MemoryAccessor { ASSERT_EQ(ret, 0); } - void copy(void *dst_ptr, void *src_ptr, size_t size) { + void copy(void *dst_ptr, void *src_ptr, size_t size) override { ASSERT_NE(hContext_, nullptr); ASSERT_GE(hDevice_, -1); ASSERT_NE(dst_ptr, nullptr); @@ -126,6 +126,8 @@ class CUDAMemoryAccessor : public MemoryAccessor { ASSERT_EQ(ret, 0); } + const char *getName() override { return "CUDAMemoryAccessor"; } + private: CUdevice hDevice_; CUcontext hContext_; @@ -610,7 +612,14 @@ TEST_P(umfCUDAProviderAllocFlagsTest, reuseParams) { INSTANTIATE_TEST_SUITE_P(umfCUDAProviderTestSuite, umfCUDAProviderTest, ::testing::Values(UMF_MEMORY_TYPE_DEVICE, UMF_MEMORY_TYPE_SHARED, - UMF_MEMORY_TYPE_HOST)); + UMF_MEMORY_TYPE_HOST), + ([](auto const &info) { + static const char *names[] = { + "UMF_MEMORY_TYPE_DEVICE", + "UMF_MEMORY_TYPE_SHARED", + "UMF_MEMORY_TYPE_HOST"}; + return std::string(names[info.index]); + })); INSTANTIATE_TEST_SUITE_P( umfCUDAProviderAllocFlagsTestSuite, umfCUDAProviderAllocFlagsTest, @@ -619,7 +628,13 @@ INSTANTIATE_TEST_SUITE_P( std::make_tuple(UMF_MEMORY_TYPE_SHARED, CU_MEM_ATTACH_HOST), std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_PORTABLE), std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_DEVICEMAP), - std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_WRITECOMBINED))); + std::make_tuple(UMF_MEMORY_TYPE_HOST, CU_MEMHOSTALLOC_WRITECOMBINED)), + ([](auto const &info) { + static const char *names[] = {"SHARED_GLOBAL", "SHARED_HOST", + "HOST_PORTABLE", "HOST_DEVICEMAP", + "HOST_WRITECOMBINED"}; + return std::string(names[info.index]); + })); // TODO: add IPC API GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest); diff --git a/test/providers/provider_level_zero.cpp b/test/providers/provider_level_zero.cpp index d6d479a14..183eaf99f 100644 --- a/test/providers/provider_level_zero.cpp +++ b/test/providers/provider_level_zero.cpp @@ -113,7 +113,14 @@ struct LevelZeroProviderInit INSTANTIATE_TEST_SUITE_P(, LevelZeroProviderInit, ::testing::Values(UMF_MEMORY_TYPE_HOST, UMF_MEMORY_TYPE_DEVICE, - UMF_MEMORY_TYPE_SHARED)); + UMF_MEMORY_TYPE_SHARED), + ([](auto const &info) { + static const char *names[] = { + "UMF_MEMORY_TYPE_HOST", + "UMF_MEMORY_TYPE_SHARED", + "UMF_MEMORY_TYPE_DEVICE"}; + return std::string(names[info.index]); + })); TEST_P(LevelZeroProviderInit, FailNullContext) { const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps(); @@ -216,7 +223,7 @@ class LevelZeroMemoryAccessor : public MemoryAccessor { ze_device_handle_t hDevice) : hDevice_(hDevice), hContext_(hContext) {} void fill(void *ptr, size_t size, const void *pattern, - size_t pattern_size) { + size_t pattern_size) override { ASSERT_NE(ptr, nullptr); int ret = utils_ze_level_zero_fill(hContext_, hDevice_, ptr, size, @@ -224,7 +231,7 @@ class LevelZeroMemoryAccessor : public MemoryAccessor { ASSERT_EQ(ret, 0); } - void copy(void *dst_ptr, void *src_ptr, size_t size) { + void copy(void *dst_ptr, void *src_ptr, size_t size) override { ASSERT_NE(dst_ptr, nullptr); ASSERT_NE(src_ptr, nullptr); @@ -233,6 +240,8 @@ class LevelZeroMemoryAccessor : public MemoryAccessor { ASSERT_EQ(ret, 0); } + const char *getName() override { return "LevelZeroMemoryAccessor"; } + private: ze_device_handle_t hDevice_; ze_context_handle_t hContext_; @@ -486,11 +495,16 @@ TEST_P(umfLevelZeroProviderTest, setDeviceOrdinalValid) { // TODO add tests that mixes Level Zero Memory Provider and Disjoint Pool -INSTANTIATE_TEST_SUITE_P(umfLevelZeroProviderTestSuite, - umfLevelZeroProviderTest, - ::testing::Values(UMF_MEMORY_TYPE_DEVICE, - UMF_MEMORY_TYPE_SHARED, - UMF_MEMORY_TYPE_HOST)); +INSTANTIATE_TEST_SUITE_P( + umfLevelZeroProviderTestSuite, umfLevelZeroProviderTest, + ::testing::Values(UMF_MEMORY_TYPE_DEVICE, UMF_MEMORY_TYPE_SHARED, + UMF_MEMORY_TYPE_HOST), + ([](auto const &info) { + static const char *names[] = {"UMF_MEMORY_TYPE_DEVICE", + "UMF_MEMORY_TYPE_SHARED", + "UMF_MEMORY_TYPE_HOST"}; + return std::string(names[info.index]); + })); LevelZeroTestHelper l0TestHelper; @@ -512,5 +526,6 @@ INSTANTIATE_TEST_SUITE_P( umfLevelZeroProviderTestSuite, umfIpcTest, ::testing::Values(ipcTestParams{ umfProxyPoolOps(), nullptr, nullptr, umfLevelZeroMemoryProviderOps(), - createL0ParamsDeviceMemory, destroyL0Params, &l0Accessor})); + createL0ParamsDeviceMemory, destroyL0Params, &l0Accessor}), + ipcTestParamsNameGen); #endif diff --git a/test/test_pool_null_params.cpp b/test/test_pool_null_params.cpp index b4eeae00d..53d3d6b36 100644 --- a/test/test_pool_null_params.cpp +++ b/test/test_pool_null_params.cpp @@ -55,7 +55,22 @@ const PoolOpsFn poolOpsList[] = { &umfProxyPoolOps #endif &umfDisjointPoolOps}; + +static const char *poolOpsNames[] = { +#if defined(UMF_POOL_SCALABLE_ENABLED) + "umfScalablePoolOps", +#endif +#if defined(UMF_POOL_JEMALLOC_ENABLED) + "umfJemallocPoolOps", +#endif +#if defined(UMF_POOL_PROXY_ENABLED) + "umfProxyPoolOps", +#endif + "umfDisjointPoolOps"}; } // namespace INSTANTIATE_TEST_SUITE_P(poolNullParamsTest, PoolNullParamsTest, - ::testing::ValuesIn(poolOpsList)); + ::testing::ValuesIn(poolOpsList), + ([](auto const &info) { + return std::string(poolOpsNames[info.index]); + })); diff --git a/test/utils/cpp_helpers.hpp b/test/utils/cpp_helpers.hpp index ca1940e16..c9c9d961b 100644 --- a/test/utils/cpp_helpers.hpp +++ b/test/utils/cpp_helpers.hpp @@ -10,11 +10,6 @@ #ifndef UMF_TEST_HELPERS_HPP #define UMF_TEST_HELPERS_HPP 1 -#include -#include -#include -#include - #include #include #include @@ -22,11 +17,17 @@ #include #include +#include +#include +#include +#include + namespace umf_test { using pool_unique_handle_t = std::unique_ptr>; + using provider_unique_handle_t = std::unique_ptr>;