Clean-up output after each test unit in offline compiler

Aditionally fix:
- GivenSpecifiedOutputDirWithProductConfigValueWhenBuilding...
...MultiCommandThenSuccessIsReturned
- GivenArgsWhenBuildingWithDeviceConfigValueThenBuildSucceeds
tests which used files created by previously run tests.
Now both of these tests are a separate units.

Related-To: NEO-6606
Signed-off-by: Fabian Zwolinski <[email protected]>

Author: fzwolinski

opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h

@@ -5,9 +5,13 @@
  *
  */
 
+#pragma once
+
 #include "shared/offline_compiler/source/ocloc_arg_helper.h"
 #include "shared/source/helpers/string.h"
 
+#include "gtest/gtest.h"
+
 #include <algorithm>
 #include <map>
 #include <string>
@@ -22,22 +26,47 @@ class MockOclocArgHelper : public OclocArgHelper {
     bool interceptOutput{false};
     bool shouldReturnReadingError{false};
     FilesMap interceptedFiles;
+    std::vector<std::string> createdFiles{};
+    bool callBaseFileExists = false;
+    bool callBaseReadBinaryFile = false;
+    bool callBaseLoadDataFromFile = false;
+    bool callBaseSaveOutput = false;
 
-    MockOclocArgHelper(FilesMap &filesMap) : OclocArgHelper(
-                                                 0, nullptr, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr),
+    MockOclocArgHelper(FilesMap &filesMap) : OclocArgHelper(0, nullptr, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr),
                                              filesMap(filesMap){};
 
+    ~MockOclocArgHelper() {
+        cleanUpOutput();
+    }
+
+    void setAllCallBase(bool value) {
+        callBaseFileExists = value;
+        callBaseReadBinaryFile = value;
+        callBaseLoadDataFromFile = value;
+        callBaseSaveOutput = value;
+    }
+
   protected:
     bool fileExists(const std::string &filename) const override {
+        if (callBaseFileExists) {
+            return OclocArgHelper::fileExists(filename);
+        }
         return filesMap.find(filename) != filesMap.end();
     }
 
     std::vector<char> readBinaryFile(const std::string &filename) override {
+        if (callBaseReadBinaryFile) {
+            return OclocArgHelper::readBinaryFile(filename);
+        }
         auto file = filesMap[filename];
         return std::vector<char>(file.begin(), file.end());
     }
 
     std::unique_ptr<char[]> loadDataFromFile(const std::string &filename, size_t &retSize) override {
+        if (callBaseLoadDataFromFile) {
+            return OclocArgHelper::loadDataFromFile(filename, retSize);
+        }
+
         if (shouldReturnReadingError) {
             return nullptr;
         }
@@ -62,7 +91,21 @@ class MockOclocArgHelper : public OclocArgHelper {
 
             memcpy_s(fileContent.data(), fileContent.size(), pData, dataSize);
         } else {
+            if (callBaseSaveOutput) {
+                createdFiles.push_back(filename.c_str());
+            }
             OclocArgHelper::saveOutput(filename, pData, dataSize);
         }
     }
+
+    void cleanUpOutput() {
+        for (const auto &fileName : createdFiles) {
+            int retVal = remove(fileName.c_str());
+            EXPECT_EQ(0, retVal);
+            if (retVal != 0) {
+                auto errMsg = "Error deleting file: " + fileName;
+                perror(errMsg.c_str());
+            }
+        }
+    }
 };

opencl/test/unit_test/offline_compiler/mock/mock_offline_compiler.h

@@ -6,8 +6,11 @@
  */
 
 #pragma once
+
 #include "shared/offline_compiler/source/offline_compiler.h"
 
+#include "opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h"
+
 #include <string>
 
 namespace NEO {
@@ -48,7 +51,8 @@ class MockOfflineCompiler : public OfflineCompiler {
     using OfflineCompiler::useOptionsSuffix;
 
     MockOfflineCompiler() : OfflineCompiler() {
-        uniqueHelper = std::make_unique<OclocArgHelper>();
+        uniqueHelper = std::make_unique<MockOclocArgHelper>(filesMap);
+        uniqueHelper->setAllCallBase(true);
         argHelper = uniqueHelper.get();
     }
     ~MockOfflineCompiler() override = default;
@@ -79,14 +83,16 @@ class MockOfflineCompiler : public OfflineCompiler {
     }
 
     void clearLog() {
-        uniqueHelper = std::make_unique<OclocArgHelper>();
+        uniqueHelper = std::make_unique<MockOclocArgHelper>(filesMap);
+        uniqueHelper->setAllCallBase(true);
         argHelper = uniqueHelper.get();
     }
 
+    std::map<std::string, std::string> filesMap{};
     int buildSourceCodeStatus = 0;
     bool overrideBuildSourceCodeStatus = false;
     uint32_t generateElfBinaryCalled = 0u;
     uint32_t writeOutAllFilesCalled = 0u;
-    std::unique_ptr<OclocArgHelper> uniqueHelper;
+    std::unique_ptr<MockOclocArgHelper> uniqueHelper;
 };
 } // namespace NEO

opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp

@@ -185,8 +185,14 @@ TEST_F(MultiCommandTests, GivenSpecifiedOutputDirWithProductConfigValueWhenBuild
     if (allEnabledDeviceConfigs.empty()) {
         GTEST_SKIP();
     }
-    auto deviceMapConfig = allEnabledDeviceConfigs[0];
-    auto configStr = oclocArgHelperWithoutInput->parseProductConfigFromValue(deviceMapConfig.config);
+
+    std::string configStr;
+    for (auto &deviceMapConfig : allEnabledDeviceConfigs) {
+        if (productFamily == deviceMapConfig.hwInfo->platform.eProductFamily) {
+            configStr = oclocArgHelperWithoutInput->parseProductConfigFromValue(deviceMapConfig.config);
+            break;
+        }
+    }
 
     nameOfFileWithArgs = "test_files/ImAMulitiComandMinimalGoodFile.txt";
     std::vector<std::string> argv = {
@@ -705,15 +711,21 @@ TEST_F(OfflineCompilerTests, GivenArgsWhenBuildingWithDeviceConfigValueThenBuild
     if (allEnabledDeviceConfigs.empty()) {
         return;
     }
-    auto deviceMapConfig = allEnabledDeviceConfigs[0];
-    auto configString = oclocArgHelperWithoutInput->parseProductConfigFromValue(deviceMapConfig.config);
+
+    std::string configStr;
+    for (auto &deviceMapConfig : allEnabledDeviceConfigs) {
+        if (productFamily == deviceMapConfig.hwInfo->platform.eProductFamily) {
+            configStr = oclocArgHelperWithoutInput->parseProductConfigFromValue(deviceMapConfig.config);
+            break;
+        }
+    }
 
     std::vector<std::string> argv = {
         "ocloc",
         "-file",
         "test_files/copybuffer.cl",
         "-device",
-        configString};
+        configStr};
 
     pOfflineCompiler = OfflineCompiler::create(argv.size(), argv, true, retVal, oclocArgHelperWithoutInput.get());
 
@@ -1207,9 +1219,6 @@ TEST(OfflineCompilerTest, givenSpvOnlyOptionPassedWhenCmdLineParsedThenGenerateO
     EXPECT_TRUE(compilerOutputExists("myOutputFileName", "bc") || compilerOutputExists("myOutputFileName", "spv"));
     EXPECT_FALSE(compilerOutputExists("myOutputFileName", "bin"));
     EXPECT_FALSE(compilerOutputExists("myOutputFileName", "gen"));
-
-    compilerOutputRemove("myOutputFileName", "bc");
-    compilerOutputRemove("myOutputFileName", "spv");
 }
 
 TEST(OfflineCompilerTest, GivenKernelWhenNoCharAfterKernelSourceThenBuildWithSuccess) {
@@ -1416,11 +1425,6 @@ TEST(OfflineCompilerTest, givenOutputFileOptionWhenSourceIsCompiledThenOutputFil
     EXPECT_TRUE(compilerOutputExists("myOutputFileName", "bc") || compilerOutputExists("myOutputFileName", "spv"));
     EXPECT_TRUE(compilerOutputExists("myOutputFileName", "bin"));
     EXPECT_TRUE(compilerOutputExists("myOutputFileName", "gen"));
-
-    compilerOutputRemove("myOutputFileName", "bc");
-    compilerOutputRemove("myOutputFileName", "spv");
-    compilerOutputRemove("myOutputFileName", "bin");
-    compilerOutputRemove("myOutputFileName", "gen");
 }
 
 TEST(OfflineCompilerTest, givenDebugDataAvailableWhenSourceIsBuiltThenDebugDataFileIsCreated) {
@@ -1459,12 +1463,6 @@ TEST(OfflineCompilerTest, givenDebugDataAvailableWhenSourceIsBuiltThenDebugDataF
     EXPECT_TRUE(compilerOutputExists("myOutputFileName", "gen"));
     EXPECT_TRUE(compilerOutputExists("myOutputFileName", "dbg"));
 
-    compilerOutputRemove("myOutputFileName", "bc");
-    compilerOutputRemove("myOutputFileName", "spv");
-    compilerOutputRemove("myOutputFileName", "bin");
-    compilerOutputRemove("myOutputFileName", "gen");
-    compilerOutputRemove("myOutputFileName", "dbg");
-
     NEO::setIgcDebugVars(gEnvironment->igcDebugVars);
 }
 

opencl/test/unit_test/offline_compiler/offline_compiler_tests.h

@@ -11,6 +11,8 @@
 #include "shared/offline_compiler/source/ocloc_error_code.h"
 #include "shared/offline_compiler/source/offline_compiler.h"
 
+#include "opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h"
+
 #include "gtest/gtest.h"
 
 #include <cstdint>
@@ -22,7 +24,13 @@ class OfflineCompilerTests : public ::testing::Test {
   public:
     OfflineCompiler *pOfflineCompiler = nullptr;
     int retVal = OclocErrorCode::SUCCESS;
-    std::unique_ptr<OclocArgHelper> oclocArgHelperWithoutInput = std::make_unique<OclocArgHelper>();
+    std::map<std::string, std::string> filesMap;
+    std::unique_ptr<MockOclocArgHelper> oclocArgHelperWithoutInput = std::make_unique<MockOclocArgHelper>(filesMap);
+
+  protected:
+    void SetUp() override {
+        oclocArgHelperWithoutInput->setAllCallBase(true);
+    }
 };
 
 class MultiCommandTests : public ::testing::Test {
@@ -34,6 +42,12 @@ class MultiCommandTests : public ::testing::Test {
     std::string nameOfFileWithArgs;
     std::string outFileList;
     int retVal = OclocErrorCode::SUCCESS;
-    std::unique_ptr<OclocArgHelper> oclocArgHelperWithoutInput = std::make_unique<OclocArgHelper>();
+    std::map<std::string, std::string> filesMap;
+    std::unique_ptr<MockOclocArgHelper> oclocArgHelperWithoutInput = std::make_unique<MockOclocArgHelper>(filesMap);
+
+  protected:
+    void SetUp() override {
+        oclocArgHelperWithoutInput->setAllCallBase(true);
+    }
 };
 } // namespace NEO