Decrease number of classes deriving from Program 2/n

Change-Id: I67a6e26f62c4bfdcdcea591ca4af3d4ce4f9980e
Signed-off-by: Maciej Dziuban <[email protected]>

Author: DziubanMaciejIntel

unit_tests/mocks/mock_program.h

@@ -42,6 +42,8 @@ class MockProgram : public Program {
     using Program::isKernelDebugEnabled;
     using Program::rebuildProgramFromIr;
 
+    using Program::sourceCode;
+
     MockProgram() : Program() {}
     MockProgram(Context *context, bool isBuiltinKernel) : Program(context, isBuiltinKernel) {}
     ~MockProgram() {

unit_tests/program/process_spir_binary_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -22,51 +22,59 @@
 
 #include "runtime/helpers/string.h"
 #include "runtime/program/program.h"
+
+#include "unit_tests/mocks/mock_program.h"
+
 #include "gtest/gtest.h"
 
 using namespace OCLRT;
 
-class ProcessSpirBinaryTests : public Program,
-                               public ::testing::Test {
+class ProcessSpirBinaryTests : public ::testing::Test {
+  public:
+    void SetUp() override {
+        program = std::make_unique<MockProgram>();
+    }
+
+    std::unique_ptr<MockProgram> program;
 };
 
 TEST_F(ProcessSpirBinaryTests, NullBinary) {
-    auto retVal = processSpirBinary(nullptr, 0, false);
+    auto retVal = program->processSpirBinary(nullptr, 0, false);
 
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(true, sourceCode.empty());
+    EXPECT_EQ(true, program->sourceCode.empty());
 }
 
 TEST_F(ProcessSpirBinaryTests, InvalidSizeBinary) {
     char pBinary[] = "somebinary\0";
     size_t binarySize = 1;
-    auto retVal = processSpirBinary(pBinary, binarySize, false);
+    auto retVal = program->processSpirBinary(pBinary, binarySize, false);
 
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(binarySize, sourceCode.size());
+    EXPECT_EQ(binarySize, program->sourceCode.size());
 }
 
 TEST_F(ProcessSpirBinaryTests, SomeBinary) {
     char pBinary[] = "somebinary\0";
     size_t binarySize = strnlen_s(pBinary, 11);
-    auto retVal = processSpirBinary(pBinary, binarySize, false);
+    auto retVal = program->processSpirBinary(pBinary, binarySize, false);
 
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(0, strcmp(pBinary, sourceCode.c_str()));
-    EXPECT_EQ(binarySize, sourceCode.size());
+    EXPECT_EQ(0, strcmp(pBinary, program->sourceCode.c_str()));
+    EXPECT_EQ(binarySize, program->sourceCode.size());
 
     // Verify no built log is available
-    auto pBuildLog = getBuildLog(pDevice);
+    auto pBuildLog = program->getBuildLog(program->getDevicePtr());
     EXPECT_EQ(nullptr, pBuildLog);
 }
 
 TEST_F(ProcessSpirBinaryTests, SpirvBinary) {
     const uint32_t pBinary[2] = {0x03022307, 0x07230203};
     size_t binarySize = sizeof(pBinary);
 
-    processSpirBinary(pBinary, binarySize, false);
-    EXPECT_FALSE(this->isSpirV);
+    program->processSpirBinary(pBinary, binarySize, false);
+    EXPECT_FALSE(program->getIsSpirV());
 
-    processSpirBinary(pBinary, binarySize, true);
-    EXPECT_TRUE(this->isSpirV);
+    program->processSpirBinary(pBinary, binarySize, true);
+    EXPECT_TRUE(program->getIsSpirV());
 }

unit_tests/program/program_tests.cpp

@@ -19,34 +19,37 @@
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  */
-#include "runtime/kernel/kernel.h"
+
+#include "program_tests.h"
+
+#include "elf/reader.h"
 #include "runtime/command_stream/command_stream_receiver_hw.h"
 #include "runtime/compiler_interface/compiler_options.h"
-#include "unit_tests/libult/ult_command_stream_receiver.h"
-#include "runtime/indirect_heap/indirect_heap.h"
 #include "runtime/helpers/aligned_memory.h"
 #include "runtime/helpers/hash.h"
 #include "runtime/helpers/hw_helper.h"
 #include "runtime/helpers/kernel_commands.h"
 #include "runtime/helpers/ptr_math.h"
 #include "runtime/helpers/string.h"
+#include "runtime/indirect_heap/indirect_heap.h"
+#include "runtime/kernel/kernel.h"
 #include "runtime/memory_manager/graphics_allocation.h"
 #include "runtime/memory_manager/surface.h"
 #include "runtime/program/create.inl"
-#include "program_tests.h"
+#include "unit_tests/fixtures/device_fixture.h"
 #include "unit_tests/fixtures/program_fixture.inl"
 #include "unit_tests/global_environment.h"
 #include "unit_tests/helpers/debug_manager_state_restore.h"
 #include "unit_tests/helpers/kernel_binary_helper.h"
+#include "unit_tests/libult/ult_command_stream_receiver.h"
 #include "unit_tests/mocks/mock_kernel.h"
+#include "unit_tests/mocks/mock_program.h"
 #include "unit_tests/program/program_from_binary.h"
 #include "unit_tests/program/program_with_source.h"
-#include "test.h"
-#include "unit_tests/fixtures/device_fixture.h"
-#include "unit_tests/mocks/mock_program.h"
+#include "unit_tests/utilities/base_object_utils.h"
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
-#include "elf/reader.h"
+#include "test.h"
 
 #include <map>
 #include <memory>
@@ -2888,9 +2891,6 @@ TEST_F(ProgramTests, givenCompilerInterfaceWhenCompileIsCalledThenProperIntermed
         }
     };
 
-    struct SmallMockProgram : public Program {};
-    using ProgramAutoPtr = std::unique_ptr<SmallMockProgram, void (*)(SmallMockProgram *)>;
-
     auto device = castToObject<Device>(pContext->getDevice(0));
 
     TranslationArgs input = {};
@@ -2908,32 +2908,27 @@ TEST_F(ProgramTests, givenCompilerInterfaceWhenCompileIsCalledThenProperIntermed
     compilerMain->setDefaultCreatorFunc<OCLRT::MockFclOclDeviceCtx>(OCLRT::MockFclOclDeviceCtx::Create);
 
     compilerInterface.useLlvmText = true;
-    ProgramAutoPtr programLlvmText{new SmallMockProgram(), [](SmallMockProgram *p) { p->release(); }};
+    auto programLlvmText = wrapReleasableObjectWithUniquePtr(new MockProgram());
     programLlvmText->setDevice(device);
     compilerInterface.intermediateRepresentation = IGC::CodeType::spirV;
     compilerInterface.compile(*programLlvmText, input);
     EXPECT_FALSE(programLlvmText->getIsSpirV());
 
     compilerInterface.useLlvmText = false;
-    ProgramAutoPtr programSpirV{new SmallMockProgram(), [](SmallMockProgram *p) { p->release(); }};
+    auto programSpirV = wrapReleasableObjectWithUniquePtr(new MockProgram());
     programSpirV->setDevice(device);
     compilerInterface.intermediateRepresentation = IGC::CodeType::spirV;
     compilerInterface.compile(*programSpirV, input);
     EXPECT_TRUE(programSpirV->getIsSpirV());
 
-    ProgramAutoPtr programLlvmBc{new SmallMockProgram(), [](SmallMockProgram *p) { p->release(); }};
+    auto programLlvmBc = wrapReleasableObjectWithUniquePtr(new MockProgram());
     programLlvmBc->setDevice(device);
     compilerInterface.intermediateRepresentation = IGC::CodeType::llvmBc;
     compilerInterface.compile(*programLlvmBc, input);
     EXPECT_FALSE(programLlvmBc->getIsSpirV());
 }
 
 TEST_F(ProgramTests, givenProgramWithSpirvWhenRebuildProgramIsCalledThenSpirvPathIsTaken) {
-    struct SmallMockProgram : public Program {
-        using Program::rebuildProgramFromIr;
-    };
-    using ProgramAutoPtr = std::unique_ptr<SmallMockProgram, void (*)(SmallMockProgram *)>;
-
     auto device = castToObject<Device>(pContext->getDevice(0));
 
     MockCompilerInterface compilerInterface;
@@ -2952,7 +2947,7 @@ TEST_F(ProgramTests, givenProgramWithSpirvWhenRebuildProgramIsCalledThenSpirvPat
     gEnvironment->igcPushDebugVars(debugVars);
     std::unique_ptr<void, void (*)(void *)> igcDebugVarsAutoPop{&gEnvironment, [](void *) { gEnvironment->igcPopDebugVars(); }};
 
-    ProgramAutoPtr program{new SmallMockProgram(), [](SmallMockProgram *p) { p->release(); }};
+    auto program = wrapReleasableObjectWithUniquePtr(new MockProgram());
     program->setDevice(device);
     uint32_t spirv[16] = {0x03022307, 0x23471113, 0x17192329};
     program->storeIrBinary(spirv, sizeof(spirv), true);

unit_tests/utilities/CMakeLists.txt

@@ -19,6 +19,7 @@
 # OTHER DEALINGS IN THE SOFTWARE.
 
 set(IGDRCL_SRCS_tests_utilities
+  ${CMAKE_CURRENT_SOURCE_DIR}/base_object_utils.h
   ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
   ${CMAKE_CURRENT_SOURCE_DIR}/containers_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/containers_tests_helpers

unit_tests/utilities/base_object_utils.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2018, Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+#include <memory>
+
+namespace OCLRT {
+
+template <typename T>
+using ReleaseableObjectPtr = std::unique_ptr<T, void (*)(T *)>;
+
+template <typename T>
+static ReleaseableObjectPtr<T> wrapReleasableObjectWithUniquePtr(T *object) {
+    return ReleaseableObjectPtr<T>{object, [](T *p) { p->release(); }};
+}
+} // namespace OCLRT