diff --git a/test/usm/CMakeLists.txt b/test/usm/CMakeLists.txt
index e0cb5fd943..6c57241fb2 100644
--- a/test/usm/CMakeLists.txt
+++ b/test/usm/CMakeLists.txt
@@ -17,7 +17,7 @@ function(add_usm_test name)
         ${PROJECT_NAME}::loader
         ur_testing
         GTest::gtest_main)
-    add_test(NAME  usm-${name}
+    add_test(NAME usm-${name}
         COMMAND ${TEST_TARGET_NAME}
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
     set_tests_properties(usm-${name} PROPERTIES LABELS "usm")
diff --git a/test/usm/pool.hpp b/test/usm/pool.hpp
new file mode 100644
index 0000000000..efb8f449b0
--- /dev/null
+++ b/test/usm/pool.hpp
@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See LICENSE.TXT
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#ifndef USM_TEST_POOL_HPP
+#define USM_TEST_POOL_HPP 1
+
+#include <gtest/gtest.h>
+
+#include <umf/base.h>
+#include <umf/memory_provider.h>
+
+#include "umf_helpers.hpp"
+
+namespace usm_test {
+
+struct null_provider {
+    umf_result_t initialize() noexcept { return UMF_RESULT_SUCCESS; };
+    enum umf_result_t alloc(size_t, size_t, void **) noexcept {
+        return UMF_RESULT_SUCCESS;
+    }
+    enum umf_result_t free(void *, size_t) noexcept {
+        return UMF_RESULT_SUCCESS;
+    }
+    enum umf_result_t get_recommended_page_size(size_t, size_t *) noexcept {
+        return UMF_RESULT_SUCCESS;
+    }
+    enum umf_result_t get_min_page_size(void *, size_t *) noexcept {
+        return UMF_RESULT_SUCCESS;
+    }
+    enum umf_result_t purge_lazy(void *, size_t) noexcept {
+        return UMF_RESULT_SUCCESS;
+    }
+    enum umf_result_t purge_force(void *, size_t) noexcept {
+        return UMF_RESULT_SUCCESS;
+    }
+    void get_last_native_error(const char **, int32_t *) noexcept {}
+    const char *get_name() noexcept { return "null"; }
+};
+
+umf::provider_unique_handle_t nullProviderCreate() {
+    auto [ret, provider] = umf::memoryProviderMakeUnique<null_provider>();
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    return std::move(provider);
+}
+
+struct null_pool {
+    umf_result_t initialize(umf_memory_provider_handle_t *, size_t) noexcept {
+        return UMF_RESULT_SUCCESS;
+    };
+    void *malloc(size_t) noexcept { return nullptr; }
+    void *calloc(size_t, size_t) noexcept { return nullptr; }
+    void *realloc(void *, size_t) noexcept { return nullptr; }
+    void *aligned_malloc(size_t, size_t) noexcept { return nullptr; }
+    void free(void *) noexcept { return; }
+    size_t malloc_usable_size(void *) noexcept { return 0; }
+    enum umf_result_t get_last_allocation_error() noexcept {
+        return UMF_RESULT_SUCCESS;
+    }
+};
+
+umf::pool_unique_handle_t
+nullPoolCreate(umf_memory_provider_handle_t *provider) {
+    auto [ret, pool] = umf::poolMakeUnique<null_pool>(provider, 1);
+    EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    return std::move(pool);
+}
+
+} // namespace usm_test
+
+#endif /* USM_TEST_POOL_HPP */
diff --git a/test/usm/usmPoolManager.cpp b/test/usm/usmPoolManager.cpp
index eaf44e119d..6e70c0ecd9 100644
--- a/test/usm/usmPoolManager.cpp
+++ b/test/usm/usmPoolManager.cpp
@@ -5,17 +5,20 @@
 
 #include "../unified_malloc_framework/common/pool.hpp"
 #include "../unified_malloc_framework/common/provider.hpp"
+#include "pool.hpp"
+
 #include "ur_pool_manager.hpp"
 
 #include <uur/fixtures.h>
 
+#include <random>
 #include <unordered_set>
 
-struct urUsmPoolManagerTest
+struct urUsmPoolDescriptorTest
     : public uur::urMultiDeviceContextTest,
       ::testing::WithParamInterface<ur_usm_pool_handle_t> {};
 
-TEST_P(urUsmPoolManagerTest, poolIsPerContextTypeAndDevice) {
+TEST_P(urUsmPoolDescriptorTest, poolIsPerContextTypeAndDevice) {
     auto &devices = uur::DevicesEnvironment::instance->devices;
     auto poolHandle = this->GetParam();
 
@@ -49,7 +52,42 @@ TEST_P(urUsmPoolManagerTest, poolIsPerContextTypeAndDevice) {
     ASSERT_EQ(sharedPools, devices.size() * 2);
 }
 
-INSTANTIATE_TEST_SUITE_P(urUsmPoolManagerTest, urUsmPoolManagerTest,
+INSTANTIATE_TEST_SUITE_P(urUsmPoolDescriptorTest, urUsmPoolDescriptorTest,
                          ::testing::Values(nullptr));
 
 // TODO: add test with sub-devices
+
+struct urUsmPoolManagerTest : ::testing::Test {
+    void SetUp() override {
+        auto [ret, descs] = usm::pool_descriptor::create(nullptr, nullptr);
+        ASSERT_EQ(ret, UR_RESULT_SUCCESS);
+        poolDescriptors = descs;
+    }
+
+    std::vector<usm::pool_descriptor> poolDescriptors;
+};
+
+TEST_F(urUsmPoolManagerTest, poolManagerPopulate) {
+    constexpr size_t seed = 0xC0FFEE;
+    srand(seed);
+
+    auto [ret, manager] = usm::pool_manager<usm::pool_descriptor>::create();
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+
+    for (auto &desc : poolDescriptors) {
+        // Populate the pool manager
+        auto providerUnique = usm_test::nullProviderCreate();
+        auto provider = providerUnique.get();
+        auto poolUnique = usm_test::nullPoolCreate(&provider);
+        ASSERT_NE(poolUnique, nullptr);
+        ret = manager.addPool(desc, poolUnique);
+        ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    }
+
+    for (auto &desc : poolDescriptors) {
+        // Confirm that there is a pool for each descriptor
+        auto hPoolOpt = manager.getPool(desc);
+        ASSERT_TRUE(hPoolOpt.has_value());
+        ASSERT_NE(hPoolOpt.value(), nullptr);
+    }
+}