Merge pull request #2376 from aarongreig/aaron/parameterizeAdapterTests

Enable adapter tests to run on all discovered adapters.

source/adapters/native_cpu/ur_interface_loader.cpp

@@ -207,6 +207,7 @@ UR_DLLEXPORT ur_result_t UR_APICALL urGetGlobalProcAddrTable(
   pDdiTable->pfnAdapterGetInfo = urAdapterGetInfo;
   pDdiTable->pfnAdapterRelease = urAdapterRelease;
   pDdiTable->pfnAdapterRetain = urAdapterRetain;
+  pDdiTable->pfnAdapterGetLastError = urAdapterGetLastError;
   return UR_RESULT_SUCCESS;
 }
 

test/conformance/adapter/urAdapterGet.cpp

@@ -3,9 +3,26 @@
 // See LICENSE.TXT
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "fixtures.h"
+#include <uur/fixtures.h>
 
-using urAdapterGetTest = uur::runtime::urTest;
+struct urAdapterGetTest : ::testing::Test {
+    void SetUp() override {
+        ur_device_init_flags_t device_flags = 0;
+        ASSERT_SUCCESS(urLoaderConfigCreate(&loader_config));
+        ASSERT_SUCCESS(urLoaderConfigEnableLayer(loader_config,
+                                                 "UR_LAYER_FULL_VALIDATION"));
+        ASSERT_SUCCESS(urLoaderInit(device_flags, loader_config));
+    }
+
+    void TearDown() override {
+        if (loader_config) {
+            ASSERT_SUCCESS(urLoaderConfigRelease(loader_config));
+        }
+        ASSERT_SUCCESS(urLoaderTearDown());
+    }
+
+    ur_loader_config_handle_t loader_config = nullptr;
+};
 
 TEST_F(urAdapterGetTest, Success) {
     uint32_t adapter_count;

test/conformance/adapter/urAdapterGetInfo.cpp

@@ -3,95 +3,83 @@
 // See LICENSE.TXT
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "fixtures.h"
+#include <uur/fixtures.h>
 
 #include <cstring>
 
-struct urAdapterGetInfoTest : uur::runtime::urAdapterTest,
-                              ::testing::WithParamInterface<ur_adapter_info_t> {
-
-    void SetUp() {
-        UUR_RETURN_ON_FATAL_FAILURE(uur::runtime::urAdapterTest::SetUp());
-        adapter = adapters[0];
-    }
-
-    ur_adapter_handle_t adapter;
-};
-
-std::unordered_map<ur_adapter_info_t, size_t> adapter_info_size_map = {
-    {UR_ADAPTER_INFO_BACKEND, sizeof(ur_adapter_backend_t)},
-    {UR_ADAPTER_INFO_VERSION, sizeof(uint32_t)},
-    {UR_ADAPTER_INFO_REFERENCE_COUNT, sizeof(uint32_t)},
-};
-
-INSTANTIATE_TEST_SUITE_P(
-    urAdapterGetInfo, urAdapterGetInfoTest,
-    ::testing::Values(UR_ADAPTER_INFO_BACKEND, UR_ADAPTER_INFO_VERSION,
-                      UR_ADAPTER_INFO_REFERENCE_COUNT),
-    [](const ::testing::TestParamInfo<ur_adapter_info_t> &info) {
-        std::stringstream ss;
-        ss << info.param;
-        return ss.str();
-    });
-
-TEST_P(urAdapterGetInfoTest, Success) {
+using urAdapterGetInfoTest = uur::urAdapterTest;
+
+UUR_INSTANTIATE_ADAPTER_TEST_SUITE_P(urAdapterGetInfoTest);
+
+TEST_P(urAdapterGetInfoTest, Backend) {
+    auto info_type = UR_ADAPTER_INFO_BACKEND;
     size_t size = 0;
-    ur_adapter_info_t info_type = GetParam();
     ASSERT_SUCCESS_OR_OPTIONAL_QUERY(
         urAdapterGetInfo(adapter, info_type, 0, nullptr, &size), info_type);
     ASSERT_NE(size, 0);
 
-    if (const auto expected_size = adapter_info_size_map.find(info_type);
-        expected_size != adapter_info_size_map.end()) {
-        ASSERT_EQ(expected_size->second, size);
-    }
+    ASSERT_EQ(size, sizeof(ur_adapter_backend_t));
 
     std::vector<char> info_data(size);
     ASSERT_SUCCESS(
         urAdapterGetInfo(adapter, info_type, size, info_data.data(), nullptr));
 }
 
+TEST_P(urAdapterGetInfoTest, ReferenceCount) {
+    auto info_type = UR_ADAPTER_INFO_REFERENCE_COUNT;
+    size_t size = 0;
+    ASSERT_SUCCESS_OR_OPTIONAL_QUERY(
+        urAdapterGetInfo(adapter, info_type, 0, nullptr, &size), info_type);
+    ASSERT_EQ(size, sizeof(uint32_t));
+
+    uint32_t reference_count = 0;
+    ASSERT_SUCCESS(
+        urAdapterGetInfo(adapter, info_type, size, &reference_count, nullptr));
+    ASSERT_GE(reference_count, 0);
+}
+
 TEST_P(urAdapterGetInfoTest, InvalidNullHandleAdapter) {
     size_t size = 0;
-    ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
-                     urAdapterGetInfo(nullptr, GetParam(), 0, nullptr, &size));
+    ASSERT_EQ_RESULT(
+        UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+        urAdapterGetInfo(nullptr, UR_ADAPTER_INFO_BACKEND, 0, nullptr, &size));
 }
 
-TEST_F(urAdapterGetInfoTest, InvalidEnumerationAdapterInfoType) {
+TEST_P(urAdapterGetInfoTest, InvalidEnumerationAdapterInfoType) {
     size_t size = 0;
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION,
                      urAdapterGetInfo(adapter, UR_ADAPTER_INFO_FORCE_UINT32, 0,
                                       nullptr, &size));
 }
 
-TEST_F(urAdapterGetInfoTest, InvalidSizeZero) {
+TEST_P(urAdapterGetInfoTest, InvalidSizeZero) {
     ur_adapter_backend_t backend;
     ASSERT_EQ_RESULT(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND, 0,
                                       &backend, nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 }
 
-TEST_F(urAdapterGetInfoTest, InvalidSizeSmall) {
+TEST_P(urAdapterGetInfoTest, InvalidSizeSmall) {
     ur_adapter_backend_t backend;
     ASSERT_EQ_RESULT(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND,
                                       sizeof(backend) - 1, &backend, nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 }
 
-TEST_F(urAdapterGetInfoTest, InvalidNullPointerPropValue) {
+TEST_P(urAdapterGetInfoTest, InvalidNullPointerPropValue) {
     ur_adapter_backend_t backend;
     ASSERT_EQ_RESULT(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND,
                                       sizeof(backend), nullptr, nullptr),
                      UR_RESULT_ERROR_INVALID_NULL_POINTER);
 }
 
-TEST_F(urAdapterGetInfoTest, InvalidNullPointerPropSizeRet) {
+TEST_P(urAdapterGetInfoTest, InvalidNullPointerPropSizeRet) {
     ASSERT_EQ_RESULT(
         urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND, 0, nullptr, nullptr),
         UR_RESULT_ERROR_INVALID_NULL_POINTER);
 }
 
-TEST_F(urAdapterGetInfoTest, ReferenceCountNotZero) {
+TEST_P(urAdapterGetInfoTest, ReferenceCountNotZero) {
     uint32_t referenceCount = 0;
 
     ASSERT_SUCCESS(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_REFERENCE_COUNT,
@@ -100,7 +88,7 @@ TEST_F(urAdapterGetInfoTest, ReferenceCountNotZero) {
     ASSERT_GT(referenceCount, 0);
 }
 
-TEST_F(urAdapterGetInfoTest, ValidAdapterBackend) {
+TEST_P(urAdapterGetInfoTest, ValidAdapterBackend) {
     ur_adapter_backend_t backend;
     ASSERT_SUCCESS(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND,
                                     sizeof(backend), &backend, nullptr));

test/conformance/adapter/urAdapterGetLastError.cpp

@@ -3,33 +3,35 @@
 // See LICENSE.TXT
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "fixtures.h"
+#include <uur/fixtures.h>
 
-struct urAdapterGetLastErrorTest : uur::runtime::urAdapterTest {
+struct urAdapterGetLastErrorTest : uur::urAdapterTest {
     int32_t error;
     const char *message = nullptr;
 };
 
-TEST_F(urAdapterGetLastErrorTest, Success) {
+UUR_INSTANTIATE_ADAPTER_TEST_SUITE_P(urAdapterGetLastErrorTest);
+
+TEST_P(urAdapterGetLastErrorTest, Success) {
     // We can't reliably generate a UR_RESULT_ERROR_ADAPTER_SPECIFIC error to
     // test the full functionality of this entry point, so instead do a minimal
     // smoke test and check that the call returns successfully, even if no
     // actual error was set.
     ASSERT_EQ_RESULT(UR_RESULT_SUCCESS,
-                     urAdapterGetLastError(adapters[0], &message, &error));
+                     urAdapterGetLastError(adapter, &message, &error));
 }
 
-TEST_F(urAdapterGetLastErrorTest, InvalidHandle) {
+TEST_P(urAdapterGetLastErrorTest, InvalidHandle) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
                      urAdapterGetLastError(nullptr, &message, &error));
 }
 
-TEST_F(urAdapterGetLastErrorTest, InvalidMessagePtr) {
+TEST_P(urAdapterGetLastErrorTest, InvalidMessagePtr) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
-                     urAdapterGetLastError(adapters[0], nullptr, &error));
+                     urAdapterGetLastError(adapter, nullptr, &error));
 }
 
-TEST_F(urAdapterGetLastErrorTest, InvalidErrorPtr) {
+TEST_P(urAdapterGetLastErrorTest, InvalidErrorPtr) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
-                     urAdapterGetLastError(adapters[0], &message, nullptr));
+                     urAdapterGetLastError(adapter, &message, nullptr));
 }

test/conformance/adapter/urAdapterRelease.cpp

@@ -3,18 +3,12 @@
 // See LICENSE.TXT
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "fixtures.h"
+#include <uur/fixtures.h>
 
-struct urAdapterReleaseTest : uur::runtime::urAdapterTest {
-    void SetUp() {
-        UUR_RETURN_ON_FATAL_FAILURE(uur::runtime::urAdapterTest::SetUp());
-        adapter = adapters[0];
-    }
+using urAdapterReleaseTest = uur::urAdapterTest;
+UUR_INSTANTIATE_ADAPTER_TEST_SUITE_P(urAdapterReleaseTest);
 
-    ur_adapter_handle_t adapter;
-};
-
-TEST_F(urAdapterReleaseTest, Success) {
+TEST_P(urAdapterReleaseTest, Success) {
     uint32_t referenceCountBefore = 0;
     ASSERT_SUCCESS(urAdapterRetain(adapter));
 
@@ -31,7 +25,7 @@ TEST_F(urAdapterReleaseTest, Success) {
     ASSERT_LE(referenceCountAfter, referenceCountBefore);
 }
 
-TEST_F(urAdapterReleaseTest, InvalidNullHandleAdapter) {
+TEST_P(urAdapterReleaseTest, InvalidNullHandleAdapter) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
                      urAdapterRelease(nullptr));
 }

test/conformance/adapter/urAdapterRetain.cpp

@@ -3,18 +3,12 @@
 // See LICENSE.TXT
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include "fixtures.h"
+#include <uur/fixtures.h>
 
-struct urAdapterRetainTest : uur::runtime::urAdapterTest {
-    void SetUp() {
-        UUR_RETURN_ON_FATAL_FAILURE(uur::runtime::urAdapterTest::SetUp());
-        adapter = adapters[0];
-    }
+using urAdapterRetainTest = uur::urAdapterTest;
+UUR_INSTANTIATE_ADAPTER_TEST_SUITE_P(urAdapterRetainTest);
 
-    ur_adapter_handle_t adapter;
-};
-
-TEST_F(urAdapterRetainTest, Success) {
+TEST_P(urAdapterRetainTest, Success) {
     uint32_t referenceCountBefore = 0;
 
     ASSERT_SUCCESS(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_REFERENCE_COUNT,
@@ -30,7 +24,7 @@ TEST_F(urAdapterRetainTest, Success) {
     ASSERT_GT(referenceCountAfter, referenceCountBefore);
 }
 
-TEST_F(urAdapterRetainTest, InvalidNullHandleAdapter) {
+TEST_P(urAdapterRetainTest, InvalidNullHandleAdapter) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
                      urAdapterRetain(nullptr));
 }

test/conformance/platform/fixtures.h

@@ -68,6 +68,14 @@ struct urPlatformTest : urPlatformsTest {
     ur_platform_handle_t platform;
 };
 
+#define UUR_INSTANTIATE_PLATFORM_TEST_SUITE_P(FIXTURE)                         \
+    INSTANTIATE_TEST_SUITE_P(                                                  \
+        , FIXTURE,                                                             \
+        ::testing::ValuesIn(uur::DevicesEnvironment::instance->devices),       \
+        [](const ::testing::TestParamInfo<ur_device_handle_t> &info) {         \
+            return uur::GetPlatformAndDeviceName(info.param);                  \
+        })
+
 } // namespace platform
 } // namespace uur