Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move debug setting and file reader tests to shared

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2022-05-18 17:56:20 +00:00
committed by Compute-Runtime-Automation
parent 1a04628393
commit 2ad04efd16
5 changed files with 15 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
opencl/test/unit_test/utilities/CMakeLists.txt
View File

@ -1,14 +1,11 @@
#
# Copyright (C) 2018-2021 Intel Corporation
# Copyright (C) 2018-2022 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(IGDRCL_SRCS_tests_utilities
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}debug_file_reader_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/debug_file_reader_tests.inl
${CMAKE_CURRENT_SOURCE_DIR}/debug_settings_reader_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/file_logger_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/file_logger_tests.h
${CMAKE_CURRENT_SOURCE_DIR}/tag_allocator_tests.cpp

36
opencl/test/unit_test/utilities/debug_file_reader_tests.cpp
View File

@ -1,36 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/test/unit_test/utilities/debug_file_reader_tests.inl"
using namespace NEO;
TEST(SettingsFileReader, givenTestFileWithDefaultValuesWhenTheyAreQueriedThenDefaultValuesMatch) {
// Use test settings file
std::unique_ptr<TestSettingsFileReader> reader =
std::unique_ptr<TestSettingsFileReader>(new TestSettingsFileReader(TestSettingsFileReader::testPath));
ASSERT_NE(nullptr, reader);
size_t debugVariableCount = 0;
bool variableFound = false;
bool compareSuccessful = false;
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
variableFound = reader->hasSetting(#variableName); \
EXPECT_TRUE(variableFound) << #variableName; \
compareSuccessful = (defaultValue == reader->getSetting(#variableName, defaultValue)); \
EXPECT_TRUE(compareSuccessful) << #variableName; \
debugVariableCount++;
#include "shared/source/debug_settings/release_variables.inl"
#include "debug_variables.inl"
#undef DECLARE_DEBUG_VARIABLE
size_t mapCount = reader->getStringSettingsCount();
EXPECT_EQ(mapCount, debugVariableCount);
}

262
opencl/test/unit_test/utilities/debug_file_reader_tests.inl
View File

@ -1,262 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/file_io.h"
#include "shared/source/utilities/debug_file_reader.h"
#include "shared/test/common/test_macros/test.h"
#include "gtest/gtest.h"
#include <memory>
#include <string>
using namespace NEO;
class TestSettingsFileReader : public SettingsFileReader {
public:
using SettingsFileReader::parseStream;
TestSettingsFileReader(const char *filePath = nullptr) : SettingsFileReader(filePath) {
}
~TestSettingsFileReader() override {
}
bool hasSetting(const char *settingName) {
std::map<std::string, std::string>::iterator it = settingStringMap.find(std::string(settingName));
return (it != settingStringMap.end());
}
size_t getStringSettingsCount() {
return settingStringMap.size();
}
static const char *testPath;
static const char *stringTestPath;
};
const char *TestSettingsFileReader::testPath = "./test_files/igdrcl.config";
const char *TestSettingsFileReader::stringTestPath = "./test_files/igdrcl_string.config";
TEST(SettingsFileReader, GivenFilesDoesNotExistWhenCreatingFileReaderThenCreationSucceeds) {
bool settingsFileExists = fileExists(SettingsReader::settingsFileName);
// if settings file exists, remove it
if (settingsFileExists) {
remove(SettingsReader::settingsFileName);
}
// Use current location for file read
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
}
TEST(SettingsFileReader, WhenGettingSettingThenCorrectStringValueIsReturned) {
// Use test settings file
auto reader = std::make_unique<TestSettingsFileReader>(TestSettingsFileReader::stringTestPath);
ASSERT_NE(nullptr, reader);
std::string retValue;
// StringTestKey is defined in file: unit_tests\helpers\test_debug_variables.inl
std::string returnedStringValue = reader->getSetting("StringTestKey", retValue);
// "Test Value" is a value that should be read from file defined in stringTestPath member
EXPECT_STREQ(returnedStringValue.c_str(), "TestValue");
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
{ \
dataType defaultData = defaultValue; \
dataType tempData = reader->getSetting(#variableName, defaultData); \
if (tempData == defaultData) { \
EXPECT_TRUE(true); \
} \
}
#include "shared/test/unit_test/helpers/test_debug_variables.inl"
#undef DECLARE_DEBUG_VARIABLE
}
TEST(SettingsFileReader, givenDebugFileSettingInWhichStringIsFollowedByIntegerWhenItIsParsedThenProperValuesAreObtained) {
auto reader = std::make_unique<TestSettingsFileReader>(TestSettingsFileReader::stringTestPath);
ASSERT_NE(nullptr, reader.get());
int32_t retValue = 0;
int32_t returnedIntValue = reader->getSetting("IntTestKey", retValue);
EXPECT_EQ(123, returnedIntValue);
int32_t returnedIntValueHex = reader->getSetting("IntTestKeyHex", 0);
EXPECT_EQ(0xABCD, returnedIntValueHex);
std::string retValueString;
std::string returnedStringValue = reader->getSetting("StringTestKey", retValueString);
EXPECT_STREQ(returnedStringValue.c_str(), "TestValue");
}
TEST(SettingsFileReader, GivenSettingNotInFileWhenGettingSettingThenProvidedDefaultIsReturned) {
// Use test settings file
auto reader = std::make_unique<TestSettingsFileReader>(TestSettingsFileReader::testPath);
ASSERT_NE(nullptr, reader);
bool defaultBoolValue = false;
bool returnedBoolValue = reader->getSetting("BoolSettingNotExistingInFile", defaultBoolValue);
EXPECT_EQ(defaultBoolValue, returnedBoolValue);
int32_t defaultIntValue = 123;
int32_t returnedIntValue = reader->getSetting("IntSettingNotExistingInFile", defaultIntValue);
EXPECT_EQ(defaultIntValue, returnedIntValue);
std::string defaultStringValue = "ABCD";
std::string returnedStringValue = reader->getSetting("StringSettingNotExistingInFile", defaultStringValue);
EXPECT_EQ(defaultStringValue, returnedStringValue);
}
TEST(SettingsFileReader, WhenGettingAppSpecificLocationThenCorrectLocationIsReturned) {
std::unique_ptr<TestSettingsFileReader> reader(new TestSettingsFileReader(TestSettingsFileReader::testPath));
std::string appSpecific = "cl_cache_dir";
EXPECT_EQ(appSpecific, reader->appSpecificLocation(appSpecific));
}
TEST(SettingsFileReader, givenHexNumbersSemiColonSeparatedListInInputStreamWhenParsingThenCorrectStringValueIsStored) {
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
//No settings should be parsed initially
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::stringstream inputLineWithSemiColonList("KeyName = 0x1234;0x5555");
reader->parseStream(inputLineWithSemiColonList);
std::string defaultStringValue = "FailedToParse";
std::string returnedStringValue = reader->getSetting("KeyName", defaultStringValue);
EXPECT_STREQ("0x1234;0x5555", returnedStringValue.c_str());
}
TEST(SettingsFileReader, given64bitKeyValueWhenGetSettingThenValueIsCorrect) {
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::stringstream inputLine("Example64BitKey = -18764712120594");
reader->parseStream(inputLine);
int64_t defaultValue = 0;
int64_t returnedValue = reader->getSetting("Example64BitKey", defaultValue);
EXPECT_EQ(-18764712120594, returnedValue);
}
TEST(SettingsFileReader, givenKeyValueWithoutSpacesWhenGetSettingThenValueIsCorrect) {
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::stringstream inputLine("SomeKey=12");
reader->parseStream(inputLine);
int64_t returnedValue = reader->getSetting("SomeKey", 0);
EXPECT_EQ(1u, reader->getStringSettingsCount());
EXPECT_EQ(12, returnedValue);
}
TEST(SettingsFileReader, givenKeyValueWithAdditionalWhitespaceCharactersWhenGetSettingThenValueIsCorrect) {
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::stringstream inputLine("\t \t SomeKey\t \t =\t \t 12\t \t ");
reader->parseStream(inputLine);
int64_t returnedValue = reader->getSetting("SomeKey", 0);
EXPECT_EQ(1u, reader->getStringSettingsCount());
EXPECT_EQ(12, returnedValue);
}
TEST(SettingsFileReader, givenKeyValueWithAdditionalCharactersWhenGetSettingThenValueIsIncorrect) {
{
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::stringstream inputLine("Some Key = 12");
reader->parseStream(inputLine);
EXPECT_EQ(0u, reader->getStringSettingsCount());
}
{
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::stringstream inputLine("SomeKey = 1 2");
reader->parseStream(inputLine);
EXPECT_EQ(0u, reader->getStringSettingsCount());
}
}
TEST(SettingsFileReader, givenMultipleKeysWhenGetSettingThenInvalidKeysAreSkipped) {
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::string testFile;
testFile.append("InvalidKey1 = 1 2\n");
testFile.append("ValidKey1 = 12\n");
testFile.append("InvalidKey2 = - 1\n");
testFile.append("ValidKey2 = 128\n");
std::stringstream inputFile(testFile);
reader->parseStream(inputFile);
EXPECT_EQ(2u, reader->getStringSettingsCount());
EXPECT_EQ(0, reader->getSetting("InvalidKey1", 0));
EXPECT_EQ(0, reader->getSetting("InvalidKey2", 0));
EXPECT_EQ(12, reader->getSetting("ValidKey1", 0));
EXPECT_EQ(128, reader->getSetting("ValidKey2", 0));
}
TEST(SettingsFileReader, givenNoKeyOrNoValueWhenGetSettingThenExceptionIsNotThrown) {
{
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::stringstream inputLine("= 12");
EXPECT_NO_THROW(reader->parseStream(inputLine));
EXPECT_EQ(0u, reader->getStringSettingsCount());
}
{
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::stringstream inputLine("SomeKey =");
EXPECT_NO_THROW(reader->parseStream(inputLine));
EXPECT_EQ(0u, reader->getStringSettingsCount());
}
{
auto reader = std::make_unique<TestSettingsFileReader>();
ASSERT_NE(nullptr, reader);
EXPECT_EQ(0u, reader->getStringSettingsCount());
std::stringstream inputLine("=");
EXPECT_NO_THROW(reader->parseStream(inputLine));
EXPECT_EQ(0u, reader->getStringSettingsCount());
}
}

109
opencl/test/unit_test/utilities/debug_settings_reader_tests.cpp
View File

@ -1,109 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/file_io.h"
#include "shared/source/utilities/debug_settings_reader.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/source/os_interface/ocl_reg_path.h"
#include "gtest/gtest.h"
#include <fstream>
#include <string>
using namespace NEO;
class MockSettingsReader : public SettingsReader {
public:
std::string getSetting(const char *settingName, const std::string &value) override {
return value;
}
bool getSetting(const char *settingName, bool defaultValue) override { return defaultValue; };
int64_t getSetting(const char *settingName, int64_t defaultValue) override { return defaultValue; };
int32_t getSetting(const char *settingName, int32_t defaultValue) override { return defaultValue; };
const char *appSpecificLocation(const std::string &name) override { return name.c_str(); };
};
TEST(SettingsReader, WhenCreatingSettingsReaderThenReaderIsCreated) {
SettingsReader *reader = SettingsReader::create(oclRegPath);
EXPECT_NE(nullptr, reader);
delete reader;
}
TEST(SettingsReader, GivenNoSettingsFileWhenCreatingSettingsReaderThenOsReaderIsCreated) {
remove(SettingsReader::settingsFileName);
auto fileReader = std::unique_ptr<SettingsReader>(SettingsReader::createFileReader());
EXPECT_EQ(nullptr, fileReader.get());
auto osReader = std::unique_ptr<SettingsReader>(SettingsReader::create(oclRegPath));
EXPECT_NE(nullptr, osReader.get());
}
TEST(SettingsReader, GivenSettingsFileExistsWhenCreatingSettingsReaderThenReaderIsCreated) {
bool settingsFileExists = fileExists(SettingsReader::settingsFileName);
if (!settingsFileExists) {
const char data[] = "ProductFamilyOverride = test";
writeDataToFile(SettingsReader::settingsFileName, &data, sizeof(data));
}
auto reader = std::unique_ptr<SettingsReader>(SettingsReader::create(oclRegPath));
EXPECT_NE(nullptr, reader.get());
std::string defaultValue("unk");
EXPECT_STREQ("test", reader->getSetting("ProductFamilyOverride", defaultValue).c_str());
std::remove(SettingsReader::settingsFileName);
}
TEST(SettingsReader, WhenCreatingFileReaderThenReaderIsCreated) {
bool settingsFileExists = fileExists(SettingsReader::settingsFileName);
if (!settingsFileExists) {
char data = 0;
writeDataToFile(SettingsReader::settingsFileName, &data, 0);
}
SettingsReader *reader = SettingsReader::createFileReader();
EXPECT_NE(nullptr, reader);
if (!settingsFileExists) {
remove(SettingsReader::settingsFileName);
}
delete reader;
}
TEST(SettingsReader, WhenCreatingOsReaderThenReaderIsCreated) {
SettingsReader *reader = SettingsReader::createOsReader(false, oclRegPath);
EXPECT_NE(nullptr, reader);
delete reader;
}
TEST(SettingsReader, GivenRegKeyWhenCreatingOsReaderThenReaderIsCreated) {
std::string regKey = oclRegPath;
std::unique_ptr<SettingsReader> reader(SettingsReader::createOsReader(false, regKey));
EXPECT_NE(nullptr, reader);
}
TEST(SettingsReader, GivenTrueWhenPrintingDebugStringThenPrintsToOutput) {
int i = 4;
testing::internal::CaptureStdout();
PRINT_DEBUG_STRING(true, stdout, "testing error %d", i);
std::string output = testing::internal::GetCapturedStdout();
EXPECT_STRNE(output.c_str(), "");
}
TEST(SettingsReader, GivenFalseWhenPrintingDebugStringThenNoOutput) {
int i = 4;
testing::internal::CaptureStdout();
PRINT_DEBUG_STRING(false, stderr, "Error String %d", i);
std::string output = testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.c_str(), "");
}
TEST(SettingsReader, givenNonExistingEnvVarWhenGettingEnvThenNullptrIsReturned) {
MockSettingsReader reader;
auto value = reader.getenv("ThisEnvVarDoesNotExist");
EXPECT_EQ(nullptr, value);
}