Add tests for builtin to L0

Change-Id: Ic6ab3dd6b249b339412c71d2d393dbf34e45371d
Signed-off-by: Katarzyna Cencelewska <katarzyna.cencelewska@intel.com>

level_zero/core/source/builtin/builtin_functions_lib_impl.h

@@ -24,7 +24,8 @@ struct BuiltinFunctionsLibImpl : BuiltinFunctionsLib {
     }
     ~BuiltinFunctionsLibImpl() override {
         builtins->reset();
-        pageFaultBuiltin.release();
+        pageFaultBuiltin.reset();
+        imageBuiltins->reset();
     }
 
     Kernel *getFunction(Builtin func) override;
@@ -43,5 +44,4 @@ struct BuiltinFunctionsLibImpl : BuiltinFunctionsLib {
     Device *device;
     NEO::BuiltIns *builtInsLib;
 };
-
 } // namespace L0

level_zero/core/test/unit_tests/CMakeLists.txt

@@ -119,6 +119,7 @@ endif()
 target_sources(${TARGET_NAME} PRIVATE
     $<TARGET_OBJECTS:mock_gmm>
     $<TARGET_OBJECTS:${TARGET_NAME_L0}_mocks>
+    $<TARGET_OBJECTS:${BUILTINS_BINARIES_LIB_NAME}>
 )
 
 set(TEST_MODULES

level_zero/core/test/unit_tests/sources/builtin/CMakeLists.txt

@@ -0,0 +1,10 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${TARGET_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+    ${CMAKE_CURRENT_SOURCE_DIR}/builtin_functions_tests.cpp
+)

level_zero/core/test/unit_tests/sources/builtin/builtin_functions_tests.cpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/built_ins/built_ins.h"
+#include "shared/source/execution_environment/root_device_environment.h"
+#include "shared/test/unit_test/mocks/mock_compiler_interface.h"
+
+#include "test.h"
+
+#include "level_zero/core/source/builtin/builtin_functions_lib_impl.h"
+#include "level_zero/core/source/device/device_imp.h"
+#include "level_zero/core/source/module/module.h"
+#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
+
+#include "gtest/gtest.h"
+
+namespace L0 {
+struct BuiltinFunctionsLibImpl::BuiltinData {
+    ~BuiltinData() {
+        func.reset();
+        module.reset();
+    }
+
+    std::unique_ptr<Module> module;
+    std::unique_ptr<Kernel> func;
+};
+namespace ult {
+class TestBuiltinFunctionsLibImpl : public DeviceFixture, public testing::Test {
+  public:
+    struct MockBuiltinFunctionsLibImpl : BuiltinFunctionsLibImpl {
+
+        using BuiltinFunctionsLibImpl::builtins;
+        using BuiltinFunctionsLibImpl::getFunction;
+        using BuiltinFunctionsLibImpl::imageBuiltins;
+        MockBuiltinFunctionsLibImpl(L0::Device *device, NEO::BuiltIns *builtInsLib) : BuiltinFunctionsLibImpl(device, builtInsLib) {}
+    };
+
+    void SetUp() override {
+        DeviceFixture::SetUp();
+        mockBuiltinFunctionsLibImpl.reset(new MockBuiltinFunctionsLibImpl(device, neoDevice->getBuiltIns()));
+    }
+    void TearDown() override {
+        DeviceFixture::TearDown();
+    }
+
+    std::unique_ptr<MockBuiltinFunctionsLibImpl> mockBuiltinFunctionsLibImpl;
+};
+
+HWTEST_F(TestBuiltinFunctionsLibImpl, givenInitImageFunctionWhenImageBultinsTableConstainNullptrsAndImageSupportedThenBuiltinsImageFunctionsAreLoaded) {
+    for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(ImageBuiltin::COUNT); builtId++) {
+        EXPECT_EQ(nullptr, mockBuiltinFunctionsLibImpl->imageBuiltins[builtId]);
+    }
+    if (device->getHwInfo().capabilityTable.supportsImages) {
+        mockBuiltinFunctionsLibImpl->initImageFunctions();
+        for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(ImageBuiltin::COUNT); builtId++) {
+            EXPECT_NE(nullptr, mockBuiltinFunctionsLibImpl->imageBuiltins[builtId]);
+            EXPECT_NE(nullptr, mockBuiltinFunctionsLibImpl->getImageFunction(static_cast<L0::ImageBuiltin>(builtId)));
+        }
+    }
+}
+
+HWTEST_F(TestBuiltinFunctionsLibImpl, givenInitFunctionWhenBultinsTableConstainNullptrsThenBuiltinsFunctionsAreLoaded) {
+    for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(Builtin::COUNT); builtId++) {
+        EXPECT_EQ(nullptr, mockBuiltinFunctionsLibImpl->builtins[builtId]);
+    }
+    mockBuiltinFunctionsLibImpl->initFunctions();
+    for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(Builtin::COUNT); builtId++) {
+        EXPECT_NE(nullptr, mockBuiltinFunctionsLibImpl->builtins[builtId]);
+        EXPECT_NE(nullptr, mockBuiltinFunctionsLibImpl->getFunction(static_cast<L0::Builtin>(builtId)));
+    }
+}
+
+HWTEST_F(TestBuiltinFunctionsLibImpl, givenCompilerInterfaceWhenCreateDeviceAndImageSupportedThenBuiltinsImageFunctionsAreLoaded) {
+    neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->compilerInterface.reset(new NEO::MockCompilerInterface());
+    std::unique_ptr<L0::Device> testDvice(Device::create(device->getDriverHandle(), neoDevice));
+
+    if (device->getHwInfo().capabilityTable.supportsImages) {
+        for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(ImageBuiltin::COUNT); builtId++) {
+            EXPECT_NE(nullptr, testDvice->getBuiltinFunctionsLib()->getImageFunction(static_cast<L0::ImageBuiltin>(builtId)));
+        }
+    }
+}
+
+HWTEST_F(TestBuiltinFunctionsLibImpl, givenCompilerInterfaceWhenCreateDeviceThenBuiltinsFunctionsAreLoaded) {
+    neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->compilerInterface.reset(new NEO::MockCompilerInterface());
+    std::unique_ptr<L0::Device> testDvice(Device::create(device->getDriverHandle(), neoDevice));
+
+    for (uint32_t builtId = 0; builtId < static_cast<uint32_t>(Builtin::COUNT); builtId++) {
+        EXPECT_NE(nullptr, testDvice->getBuiltinFunctionsLib()->getFunction(static_cast<L0::Builtin>(builtId)));
+    }
+}
+} // namespace ult
+} // namespace L0