intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 06:24:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "feature: Add debug/release variable prefixes"

Browse Source 
This reverts commit ec95d9314a.

Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>
This commit is contained in:
Artur Harasimiuk
2023-08-18 11:31:39 +00:00
committed by Compute-Runtime-Automation
parent 3c71062b4e
commit f6e0c0cf89
23 changed files with 59 additions and 1353 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
level_zero/core/source/helpers/api_specific_config_l0.cpp
View File

@@ -10,12 +10,7 @@
#include "level_zero/core/source/compiler_interface/l0_reg_path.h"
#include <string>
#include <vector>
namespace NEO {
std::vector<const char *> validL0Prefixes;
std::vector<NEO::DebugVarPrefix> validL0PrefixTypes;
bool ApiSpecificConfig::isStatelessCompressionSupported() {
return false;
}
@@ -56,20 +51,4 @@ const char *ApiSpecificConfig::getRegistryPath() {
return L0::registryPath;
}
void ApiSpecificConfig::initPrefixes() {
validL0Prefixes.push_back("NEO_L0_");
validL0Prefixes.push_back("NEO_");
validL0Prefixes.push_back("");
validL0PrefixTypes.push_back(DebugVarPrefix::Neo_L0);
validL0PrefixTypes.push_back(DebugVarPrefix::Neo);
validL0PrefixTypes.push_back(DebugVarPrefix::None);
}
const std::vector<const char *> &ApiSpecificConfig::getPrefixStrings() {
return validL0Prefixes;
}
const std::vector<DebugVarPrefix> &ApiSpecificConfig::getPrefixTypes() {
return validL0PrefixTypes;
}
} // namespace NEO

21
opencl/source/helpers/api_specific_config_ocl.cpp
View File

@@ -10,12 +10,7 @@
#include "opencl/source/os_interface/ocl_reg_path.h"
#include <string>
#include <vector>
namespace NEO {
std::vector<const char *> validClPrefixes;
std::vector<NEO::DebugVarPrefix> validClPrefixTypes;
bool ApiSpecificConfig::isStatelessCompressionSupported() {
return true;
}
@@ -55,20 +50,4 @@ uint64_t ApiSpecificConfig::getReducedMaxAllocSize(uint64_t maxAllocSize) {
const char *ApiSpecificConfig::getRegistryPath() {
return oclRegPath;
}
void ApiSpecificConfig::initPrefixes() {
validClPrefixes.push_back("NEO_OCL_");
validClPrefixes.push_back("NEO_");
validClPrefixes.push_back("");
validClPrefixTypes.push_back(DebugVarPrefix::Neo_Ocl);
validClPrefixTypes.push_back(DebugVarPrefix::Neo);
validClPrefixTypes.push_back(DebugVarPrefix::None);
}
const std::vector<const char *> &ApiSpecificConfig::getPrefixStrings() {
return validClPrefixes;
}
const std::vector<DebugVarPrefix> &ApiSpecificConfig::getPrefixTypes() {
return validClPrefixTypes;
}
} // namespace NEO

6
opencl/test/unit_test/os_interface/windows/driver_info_tests.cpp
View File

@@ -6,7 +6,6 @@
*/
#include "shared/source/command_stream/preemption.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/os_interface/os_interface.h"
@@ -111,8 +110,6 @@ class MockRegistryReader : public SettingsReader {
public:
std::string nameString;
std::string versionString;
std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override { return ""; };
std::string getSetting(const char *settingName, const std::string &value) override {
std::string key(settingName);
if (key == "HardwareInformation.AdapterString") {
@@ -134,11 +131,8 @@ class MockRegistryReader : public SettingsReader {
return value;
}
bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override { return defaultValue; };
bool getSetting(const char *settingName, bool defaultValue) override { return defaultValue; };
int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override { return defaultValue; };
int64_t getSetting(const char *settingName, int64_t defaultValue) override { return defaultValue; };
int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) 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(); };

62
shared/source/debug_settings/debug_settings_manager.cpp
View File

@@ -9,11 +9,9 @@
#include "shared/source/debug_settings/debug_variables_helper.h"
#include "shared/source/debug_settings/definitions/translate_debug_settings.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/helpers/debug_helpers.h"
#include "shared/source/helpers/string.h"
#include "shared/source/utilities/debug_settings_reader_creator.h"
#include "shared/source/utilities/io_functions.h"
#include "shared/source/utilities/logger.h"
#include <fstream>
@@ -35,7 +33,6 @@ static std::string toString(const T &arg) {
template <DebugFunctionalityLevel DebugLevel>
DebugSettingsManager<DebugLevel>::DebugSettingsManager(const char *registryPath) {
readerImpl = SettingsReaderCreator::create(std::string(registryPath));
ApiSpecificConfig::initPrefixes();
injectSettingsFromReader();
dumpFlags();
translateDebugSettings(flags);
@@ -60,18 +57,6 @@ void DebugSettingsManager<DebugLevel>::getHardwareInfoOverride(std::string &hwIn
}
}
static const char *convPrefixToString(DebugVarPrefix prefix) {
if (prefix == DebugVarPrefix::Neo) {
return "NEO_";
} else if (prefix == DebugVarPrefix::Neo_L0) {
return "NEO_L0_";
} else if (prefix == DebugVarPrefix::Neo_Ocl) {
return "NEO_OCL_";
} else {
return "";
}
}
template <DebugFunctionalityLevel DebugLevel>
template <typename DataType>
void DebugSettingsManager<DebugLevel>::dumpNonDefaultFlag(const char *variableName, const DataType &variableValue, const DataType &defaultValue, std::ostringstream &ostring) {
@@ -89,31 +74,18 @@ void DebugSettingsManager<DebugLevel>::getStringWithFlags(std::string &allFlags,
std::ostringstream changedFlagsStream;
changedFlagsStream.str("");
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
{ \
char neoFinal[MAX_NEO_KEY_LENGTH]; \
const char *prefix = convPrefixToString(flags.variableName.getPrefixType()); \
strcpy_s(neoFinal, strlen(prefix) + 1, prefix); \
strcpy_s(neoFinal + strlen(prefix), strlen(#variableName) + 1, #variableName); \
const char *neoKey = neoFinal; \
allFlagsStream << getNonReleaseKeyName(neoKey) << " = " << flags.variableName.get() << '\n'; \
dumpNonDefaultFlag<dataType>(getNonReleaseKeyName(neoKey), flags.variableName.get(), defaultValue, changedFlagsStream); \
}
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
allFlagsStream << getNonReleaseKeyName(#variableName) << " = " << flags.variableName.get() << '\n'; \
dumpNonDefaultFlag<dataType>(getNonReleaseKeyName(#variableName), flags.variableName.get(), defaultValue, changedFlagsStream);
if (registryReadAvailable() || isDebugKeysReadEnabled()) {
#include "debug_variables.inl"
}
#undef DECLARE_DEBUG_VARIABLE
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
{ \
char neoFinal[MAX_NEO_KEY_LENGTH]; \
const char *prefix = convPrefixToString(flags.variableName.getPrefixType()); \
strcpy_s(neoFinal, strlen(prefix) + 1, prefix); \
strcpy_s(neoFinal + strlen(prefix), strlen(#variableName) + 1, #variableName); \
const char *neoKey = neoFinal; \
allFlagsStream << neoKey << " = " << flags.variableName.get() << '\n'; \
dumpNonDefaultFlag<dataType>(neoKey, flags.variableName.get(), defaultValue, changedFlagsStream); \
}
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
allFlagsStream << #variableName << " = " << flags.variableName.get() << '\n'; \
dumpNonDefaultFlag<dataType>(#variableName, flags.variableName.get(), defaultValue, changedFlagsStream);
#include "release_variables.inl"
#undef DECLARE_DEBUG_VARIABLE
@@ -142,12 +114,10 @@ void DebugSettingsManager<DebugLevel>::dumpFlags() const {
template <DebugFunctionalityLevel DebugLevel>
void DebugSettingsManager<DebugLevel>::injectSettingsFromReader() {
#undef DECLARE_DEBUG_VARIABLE
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
{ \
DebugVarPrefix type; \
dataType tempData = readerImpl->getSetting(getNonReleaseKeyName(#variableName), flags.variableName.get(), type); \
flags.variableName.setPrefixType(type); \
flags.variableName.set(tempData); \
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
{ \
dataType tempData = readerImpl->getSetting(getNonReleaseKeyName(#variableName), flags.variableName.get()); \
flags.variableName.set(tempData); \
}
if (registryReadAvailable() || isDebugKeysReadEnabled()) {
@@ -155,12 +125,10 @@ void DebugSettingsManager<DebugLevel>::injectSettingsFromReader() {
}
#undef DECLARE_DEBUG_VARIABLE
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
{ \
DebugVarPrefix type; \
dataType tempData = readerImpl->getSetting(#variableName, flags.variableName.get(), type); \
flags.variableName.setPrefixType(type); \
flags.variableName.set(tempData); \
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
{ \
dataType tempData = readerImpl->getSetting(#variableName, flags.variableName.get()); \
flags.variableName.set(tempData); \
}
#include "release_variables.inl"
#undef DECLARE_DEBUG_VARIABLE

16
shared/source/debug_settings/debug_settings_manager.h
View File

@@ -59,13 +59,6 @@ void logDebugString(std::string_view debugString);
class SettingsReader;
enum class DebugVarPrefix : uint8_t {
None = 1,
Neo = 2,
Neo_L0 = 3,
Neo_Ocl = 4
};
template <typename T>
struct DebugVarBase {
DebugVarBase(const T &defaultValue) : value(defaultValue), defaultValue(defaultValue) {}
@@ -83,17 +76,10 @@ struct DebugVarBase {
this->set(data);
}
}
void setPrefixType(DebugVarPrefix data) {
prefixType = std::move(data);
}
DebugVarPrefix getPrefixType() const {
return prefixType;
}
private:
T value;
T defaultValue;
DebugVarPrefix prefixType = DebugVarPrefix::None;
};
struct DebugVariables { // NOLINT(clang-analyzer-optin.performance.Padding)
@@ -172,8 +158,6 @@ class DebugSettingsManager {
extern DebugSettingsManager<globalDebugFunctionalityLevel> DebugManager;
#define MAX_NEO_KEY_LENGTH 256
#define PRINT_DEBUGGER_LOG_TO_FILE(...) \
NEO::DebugManager.logLazyEvaluateArgs([&] { \
char temp[4000]; \

6
shared/source/helpers/api_specific_config.h
View File

@@ -6,11 +6,8 @@
*/
#pragma once
#include "shared/source/debug_settings/debug_settings_manager.h"
#include <cstdint>
#include <string>
#include <vector>
namespace NEO {
struct ApiSpecificConfig {
@@ -26,9 +23,6 @@ struct ApiSpecificConfig {
static uint64_t getReducedMaxAllocSize(uint64_t maxAllocSize);
static const char *getRegistryPath();
static void initPrefixes();
static const std::vector<const char *> &getPrefixStrings();
static const std::vector<DebugVarPrefix> &getPrefixTypes();
static std::string getAubPrefixForSpecificApi() {
return (getName() + "_");
}

60
shared/source/os_interface/debug_env_reader.cpp
View File

@@ -7,57 +7,22 @@
#include "shared/source/os_interface/debug_env_reader.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/utilities/io_functions.h"
#include <vector>
namespace NEO {
const char *EnvironmentVariableReader::appSpecificLocation(const std::string &name) {
return name.c_str();
}
bool EnvironmentVariableReader::getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) {
return getSetting(settingName, static_cast<int64_t>(defaultValue), type) ? true : false;
}
bool EnvironmentVariableReader::getSetting(const char *settingName, bool defaultValue) {
return getSetting(settingName, static_cast<int64_t>(defaultValue)) ? true : false;
}
int32_t EnvironmentVariableReader::getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) {
return static_cast<int32_t>(getSetting(settingName, static_cast<int64_t>(defaultValue), type));
}
int32_t EnvironmentVariableReader::getSetting(const char *settingName, int32_t defaultValue) {
return static_cast<int32_t>(getSetting(settingName, static_cast<int64_t>(defaultValue)));
}
int64_t EnvironmentVariableReader::getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) {
int64_t value = defaultValue;
char *envValue;
const std::vector<const char *> prefixString = ApiSpecificConfig::getPrefixStrings();
const std::vector<NEO::DebugVarPrefix> prefixType = ApiSpecificConfig::getPrefixTypes();
char neoFinal[MAX_NEO_KEY_LENGTH];
uint32_t i = 0;
for (const auto &prefix : prefixString) {
strcpy_s(neoFinal, strlen(prefix) + 1, prefix);
strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName);
envValue = IoFunctions::getenvPtr(neoFinal);
if (envValue) {
value = atoll(envValue);
type = prefixType[i];
return value;
}
i++;
}
type = DebugVarPrefix::None;
return value;
}
int64_t EnvironmentVariableReader::getSetting(const char *settingName, int64_t defaultValue) {
int64_t value = defaultValue;
char *envValue;
@@ -69,31 +34,6 @@ int64_t EnvironmentVariableReader::getSetting(const char *settingName, int64_t d
return value;
}
std::string EnvironmentVariableReader::getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) {
char *envValue;
std::string keyValue;
keyValue.assign(value);
const std::vector<const char *> prefixString = ApiSpecificConfig::getPrefixStrings();
const std::vector<DebugVarPrefix> prefixType = ApiSpecificConfig::getPrefixTypes();
char neoFinal[MAX_NEO_KEY_LENGTH];
uint32_t i = 0;
for (const auto &prefix : prefixString) {
strcpy_s(neoFinal, strlen(prefix) + 1, prefix);
strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName);
envValue = IoFunctions::getenvPtr(neoFinal);
if (envValue) {
keyValue.assign(envValue);
type = prefixType[i];
return keyValue;
}
i++;
}
type = DebugVarPrefix::None;
return keyValue;
}
std::string EnvironmentVariableReader::getSetting(const char *settingName, const std::string &value) {
char *envValue;
std::string keyValue;

4
shared/source/os_interface/debug_env_reader.h
View File

@@ -14,13 +14,9 @@ namespace NEO {
class EnvironmentVariableReader : public SettingsReader {
public:
int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) override;
int32_t getSetting(const char *settingName, int32_t defaultValue) override;
int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override;
int64_t getSetting(const char *settingName, int64_t defaultValue) override;
bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override;
bool getSetting(const char *settingName, bool defaultValue) override;
std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override;
std::string getSetting(const char *settingName, const std::string &value) override;
const char *appSpecificLocation(const std::string &name) override;
};

94
shared/source/os_interface/windows/debug_registry_reader.cpp
View File

@@ -8,7 +8,6 @@
#include "shared/source/os_interface/windows/debug_registry_reader.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/os_interface/windows/sys_calls.h"
#include "shared/source/os_interface/windows/windows_wrapper.h"
#include "shared/source/utilities/debug_settings_reader.h"
@@ -44,26 +43,19 @@ const char *RegistryReader::appSpecificLocation(const std::string &name) {
return name.c_str();
}
bool RegistryReader::getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) {
return getSetting(settingName, static_cast<int32_t>(defaultValue), type) ? true : false;
}
bool RegistryReader::getSetting(const char *settingName, bool defaultValue) {
return getSetting(settingName, static_cast<int32_t>(defaultValue)) ? true : false;
}
int32_t RegistryReader::getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) {
return static_cast<int32_t>(getSetting(settingName, static_cast<int64_t>(defaultValue), type));
}
int32_t RegistryReader::getSetting(const char *settingName, int32_t defaultValue) {
return static_cast<int32_t>(getSetting(settingName, static_cast<int64_t>(defaultValue)));
}
bool RegistryReader::getSettingIntCommon(const char *settingName, int64_t &value) {
int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue) {
HKEY Key{};
int64_t value = defaultValue;
DWORD success = ERROR_SUCCESS;
bool retVal = false;
bool readSettingFromEnv = true;
success = SysCalls::regOpenKeyExA(hkeyType,
registryReadRootKey.c_str(),
@@ -83,44 +75,11 @@ bool RegistryReader::getSettingIntCommon(const char *settingName, int64_t &value
&size);
if (ERROR_SUCCESS == success) {
value = regData;
retVal = true;
readSettingFromEnv = false;
}
RegCloseKey(Key);
}
return retVal;
}
int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) {
int64_t value = defaultValue;
if (!(getSettingIntCommon(settingName, value))) {
char *envValue;
const std::vector<const char *> prefixString = ApiSpecificConfig::getPrefixStrings();
const std::vector<DebugVarPrefix> prefixType = ApiSpecificConfig::getPrefixTypes();
char neoFinal[MAX_NEO_KEY_LENGTH];
uint32_t i = 0;
for (const auto &prefix : prefixString) {
strcpy_s(neoFinal, strlen(prefix) + 1, prefix);
strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName);
envValue = getenv(neoFinal);
if (envValue) {
value = atoll(envValue);
type = prefixType[i];
return value;
}
i++;
}
}
type = DebugVarPrefix::None;
return value;
}
int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue) {
int64_t value = defaultValue;
if (!(getSettingIntCommon(settingName, value))) {
if (readSettingFromEnv) {
const char *envValue = getenv(settingName);
if (envValue) {
value = atoll(envValue);
@@ -130,10 +89,11 @@ int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue
return value;
}
bool RegistryReader::getSettingStringCommon(const char *settingName, std::string &keyValue) {
std::string RegistryReader::getSetting(const char *settingName, const std::string &value) {
HKEY Key{};
DWORD success = ERROR_SUCCESS;
bool retVal = false;
std::string keyValue = value;
bool readSettingFromEnv = true;
success = SysCalls::regOpenKeyExA(hkeyType,
registryReadRootKey.c_str(),
@@ -161,7 +121,7 @@ bool RegistryReader::getSettingStringCommon(const char *settingName, std::string
&regSize);
if (success == ERROR_SUCCESS) {
keyValue.assign(regData.get());
retVal = true;
readSettingFromEnv = false;
}
} else if (regType == REG_BINARY) {
size_t charCount = regSize / sizeof(wchar_t);
@@ -180,46 +140,14 @@ bool RegistryReader::getSettingStringCommon(const char *settingName, std::string
convertedData.get()[charCount] = 0;
keyValue.assign(convertedData.get());
retVal = true;
readSettingFromEnv = false;
}
}
}
RegCloseKey(Key);
}
return retVal;
}
std::string RegistryReader::getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) {
std::string keyValue = value;
if (!(getSettingStringCommon(settingName, keyValue))) {
char *envValue;
const std::vector<const char *> prefixString = ApiSpecificConfig::getPrefixStrings();
const std::vector<DebugVarPrefix> prefixType = ApiSpecificConfig::getPrefixTypes();
char neoFinal[MAX_NEO_KEY_LENGTH];
uint32_t i = 0;
for (const auto &prefix : prefixString) {
strcpy_s(neoFinal, strlen(prefix) + 1, prefix);
strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName);
envValue = strcmp(processName.c_str(), neoFinal) ? getenv(neoFinal) : getenv("cl_cache_dir");
if (envValue) {
keyValue.assign(envValue);
type = prefixType[i];
return keyValue;
}
i++;
}
}
type = DebugVarPrefix::None;
return keyValue;
}
std::string RegistryReader::getSetting(const char *settingName, const std::string &value) {
std::string keyValue = value;
if (!(getSettingStringCommon(settingName, keyValue))) {
if (readSettingFromEnv) {
const char *envValue = strcmp(processName.c_str(), settingName) ? getenv(settingName) : getenv("cl_cache_dir");
if (envValue) {
keyValue.assign(envValue);

9
shared/source/os_interface/windows/debug_registry_reader.h
View File

@@ -15,22 +15,13 @@
#include <string>
namespace NEO {
enum class DebugVarPrefix : uint8_t;
class RegistryReader : public SettingsReader {
public:
RegistryReader() = delete;
RegistryReader(bool userScope, const std::string &regKey);
bool getSettingIntCommon(const char *settingName, int64_t &value);
bool getSettingStringCommon(const char *settingName, std::string &keyValue);
int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) override;
int32_t getSetting(const char *settingName, int32_t defaultValue) override;
int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override;
int64_t getSetting(const char *settingName, int64_t defaultValue) override;
bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override;
bool getSetting(const char *settingName, bool defaultValue) override;
std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override;
std::string getSetting(const char *settingName, const std::string &value) override;
const char *appSpecificLocation(const std::string &name) override;

55
shared/source/utilities/debug_file_reader.cpp
View File

@@ -7,7 +7,6 @@
#include "shared/source/utilities/debug_file_reader.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/helpers/debug_helpers.h"
#include <fstream>
@@ -31,37 +30,10 @@ SettingsFileReader::~SettingsFileReader() {
settingStringMap.clear();
}
int32_t SettingsFileReader::getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) {
return static_cast<int32_t>(getSetting(settingName, static_cast<int64_t>(defaultValue), type));
}
int32_t SettingsFileReader::getSetting(const char *settingName, int32_t defaultValue) {
return static_cast<int32_t>(getSetting(settingName, static_cast<int64_t>(defaultValue)));
}
int64_t SettingsFileReader::getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) {
int64_t value = defaultValue;
const std::vector<const char *> prefixString = ApiSpecificConfig::getPrefixStrings();
const std::vector<DebugVarPrefix> prefixType = ApiSpecificConfig::getPrefixTypes();
char neoFinal[MAX_NEO_KEY_LENGTH];
uint32_t i = 0;
for (const auto &prefix : prefixString) {
strcpy_s(neoFinal, strlen(prefix) + 1, prefix);
strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName);
std::map<std::string, std::string>::iterator it = settingStringMap.find(std::string(neoFinal));
if (it != settingStringMap.end()) {
value = strtoll(it->second.c_str(), nullptr, 0);
type = prefixType[i];
return value;
}
i++;
}
type = DebugVarPrefix::None;
return value;
}
int64_t SettingsFileReader::getSetting(const char *settingName, int64_t defaultValue) {
int64_t value = defaultValue;
@@ -73,37 +45,10 @@ int64_t SettingsFileReader::getSetting(const char *settingName, int64_t defaultV
return value;
}
bool SettingsFileReader::getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) {
return getSetting(settingName, static_cast<int64_t>(defaultValue), type) ? true : false;
}
bool SettingsFileReader::getSetting(const char *settingName, bool defaultValue) {
return getSetting(settingName, static_cast<int64_t>(defaultValue)) ? true : false;
}
std::string SettingsFileReader::getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) {
std::string returnValue = value;
const std::vector<const char *> prefixString = ApiSpecificConfig::getPrefixStrings();
const std::vector<DebugVarPrefix> prefixType = ApiSpecificConfig::getPrefixTypes();
char neoFinal[MAX_NEO_KEY_LENGTH];
uint32_t i = 0;
for (const auto &prefix : prefixString) {
strcpy_s(neoFinal, strlen(prefix) + 1, prefix);
strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName);
std::map<std::string, std::string>::iterator it = settingStringMap.find(std::string(neoFinal));
if (it != settingStringMap.end()) {
returnValue = it->second;
type = prefixType[i];
return returnValue;
}
i++;
}
type = DebugVarPrefix::None;
return returnValue;
}
std::string SettingsFileReader::getSetting(const char *settingName, const std::string &value) {
std::string returnValue = value;
std::map<std::string, std::string>::iterator it = settingStringMap.find(std::string(settingName));

6
shared/source/utilities/debug_file_reader.h
View File

@@ -15,19 +15,13 @@
namespace NEO {
enum class DebugVarPrefix : uint8_t;
class SettingsFileReader : public SettingsReader {
public:
SettingsFileReader(const char *filePath);
~SettingsFileReader() override;
int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) override;
int32_t getSetting(const char *settingName, int32_t defaultValue) override;
int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override;
int64_t getSetting(const char *settingName, int64_t defaultValue) override;
bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override;
bool getSetting(const char *settingName, bool defaultValue) override;
std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override;
std::string getSetting(const char *settingName, const std::string &value) override;
const char *appSpecificLocation(const std::string &name) override;

15
shared/source/utilities/debug_settings_reader.cpp
View File

@@ -10,24 +10,17 @@
#include "shared/source/utilities/debug_file_reader.h"
#include <fstream>
#include <vector>
namespace NEO {
const char *SettingsReader::settingsFileName = "igdrcl.config";
const char *SettingsReader::neoSettingsFileName = "neo.config";
SettingsReader *SettingsReader::createFileReader() {
std::ifstream settingsFile;
std::vector<const char *> fileName;
fileName.push_back(settingsFileName);
fileName.push_back(neoSettingsFileName);
for (const auto &file : fileName) {
settingsFile.open(file);
if (settingsFile.is_open()) {
settingsFile.close();
return new SettingsFileReader(file);
}
settingsFile.open(settingsFileName);
if (settingsFile.is_open()) {
settingsFile.close();
return new SettingsFileReader(settingsFileName);
}
return nullptr;
}

8
shared/source/utilities/debug_settings_reader.h
View File

@@ -6,14 +6,11 @@
*/
#pragma once
#include <stdint.h>
#include <string>
namespace NEO {
enum class DebugVarPrefix : uint8_t;
class SettingsReader {
public:
virtual ~SettingsReader() = default;
@@ -26,17 +23,12 @@ class SettingsReader {
}
static SettingsReader *createOsReader(bool userScope, const std::string &regKey);
static SettingsReader *createFileReader();
virtual int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) = 0;
virtual int32_t getSetting(const char *settingName, int32_t defaultValue) = 0;
virtual int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) = 0;
virtual int64_t getSetting(const char *settingName, int64_t defaultValue) = 0;
virtual bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) = 0;
virtual bool getSetting(const char *settingName, bool defaultValue) = 0;
virtual std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) = 0;
virtual std::string getSetting(const char *settingName, const std::string &value) = 0;
virtual const char *appSpecificLocation(const std::string &name) = 0;
static const char *settingsFileName;
static const char *neoSettingsFileName;
MOCKABLE_VIRTUAL char *getenv(const char *settingName);
};
}; // namespace NEO

6
shared/test/common/test_files/neo_string.config
View File

@@ -1,6 +0,0 @@
StringTestKey = IncorrectValue
IntTestKey = 888
IntTestKeyHex = 0xFACE
NEO_StringTestKey = TestValue
NEO_IntTestKey = 123
NEO_IntTestKeyHex = 0xABCD

194
shared/test/unit_test/debug_settings/debug_settings_manager_tests.cpp
View File

@@ -5,7 +5,6 @@
*
*/
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/memory_manager/graphics_allocation.h"
#include "shared/source/memory_manager/memory_manager.h"
#include "shared/source/utilities/debug_file_reader.h"
@@ -22,12 +21,6 @@
#include <sstream>
#include <string>
namespace NEO {
extern ApiSpecificConfig::ApiType apiTypeForUlts;
extern std::vector<const char *> validPrefixes;
extern std::vector<NEO::DebugVarPrefix> validPrefixTypes;
} // namespace NEO
TEST(DebugSettingsManager, WhenDebugManagerIsCreatedThenInjectFcnIsNull) {
FullyEnabledTestDebugManager debugManager;
@@ -121,19 +114,13 @@ TEST(DebugSettingsManager, givenReaderImplInDebugManagerWhenSettingDifferentRead
EXPECT_EQ(readerImpl2, debugManager.getReaderImpl());
}
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithNoPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) {
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) {
testing::internal::CaptureStdout();
FullyEnabledTestDebugManager debugManager;
ApiSpecificConfig::initPrefixes();
debugManager.flags.PrintDebugSettings.set(true);
debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::None);
debugManager.flags.LoopAtDriverInit.set(true);
debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::None);
debugManager.flags.Enable64kbpages.set(1);
debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::None);
debugManager.flags.TbxServer.set("192.168.0.1");
debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::None);
// Clear dump files and generate new
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
@@ -141,15 +128,11 @@ TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithNoPrefixWhenCalling
// Validate allSettingsDumpFile
SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName};
#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \
{ \
DebugVarPrefix type; \
EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \
}
#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \
EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue));
#include "debug_variables.inl"
#undef DECLARE_DEBUG_VARIABLE
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
std::string output = testing::internal::GetCapturedStdout();
ASSERT_NE(0u, output.size());
@@ -160,177 +143,6 @@ TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithNoPrefixWhenCalling
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: Enable64kbpages = 1"));
}
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithNeoPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) {
testing::internal::CaptureStdout();
FullyEnabledTestDebugManager debugManager;
ApiSpecificConfig::initPrefixes();
debugManager.flags.PrintDebugSettings.set(true);
debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::Neo);
debugManager.flags.LoopAtDriverInit.set(true);
debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::Neo);
debugManager.flags.Enable64kbpages.set(1);
debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::Neo);
debugManager.flags.TbxServer.set("192.168.0.1");
debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::Neo);
// Clear dump files and generate new
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
debugManager.dumpFlags();
// Validate allSettingsDumpFile
SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName};
#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \
{ \
DebugVarPrefix type; \
EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \
}
#include "debug_variables.inl"
#undef DECLARE_DEBUG_VARIABLE
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
std::string output = testing::internal::GetCapturedStdout();
ASSERT_NE(0u, output.size());
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_TbxServer = 192.168.0.1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_LoopAtDriverInit = 1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_PrintDebugSettings = 1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_Enable64kbpages = 1"));
}
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithLevelZeroPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) {
testing::internal::CaptureStdout();
FullyEnabledTestDebugManager debugManager;
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
debugManager.flags.PrintDebugSettings.set(true);
debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::Neo_L0);
debugManager.flags.LoopAtDriverInit.set(true);
debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::Neo_L0);
debugManager.flags.Enable64kbpages.set(1);
debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::Neo_L0);
debugManager.flags.TbxServer.set("192.168.0.1");
debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::Neo_L0);
// Clear dump files and generate new
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
debugManager.dumpFlags();
// Validate allSettingsDumpFile
SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName};
#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \
{ \
DebugVarPrefix type; \
EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \
}
#include "debug_variables.inl"
#undef DECLARE_DEBUG_VARIABLE
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
std::string output = testing::internal::GetCapturedStdout();
ASSERT_NE(0u, output.size());
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_TbxServer = 192.168.0.1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_LoopAtDriverInit = 1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_PrintDebugSettings = 1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_Enable64kbpages = 1"));
}
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithOclPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) {
testing::internal::CaptureStdout();
FullyEnabledTestDebugManager debugManager;
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::OCL);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
debugManager.flags.PrintDebugSettings.set(true);
debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::Neo_Ocl);
debugManager.flags.LoopAtDriverInit.set(true);
debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::Neo_Ocl);
debugManager.flags.Enable64kbpages.set(1);
debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::Neo_Ocl);
debugManager.flags.TbxServer.set("192.168.0.1");
debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::Neo_Ocl);
// Clear dump files and generate new
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
debugManager.dumpFlags();
// Validate allSettingsDumpFile
SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName};
#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \
{ \
DebugVarPrefix type; \
EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \
}
#include "debug_variables.inl"
#undef DECLARE_DEBUG_VARIABLE
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
std::string output = testing::internal::GetCapturedStdout();
ASSERT_NE(0u, output.size());
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_OCL_TbxServer = 192.168.0.1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_OCL_LoopAtDriverInit = 1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_OCL_PrintDebugSettings = 1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_OCL_Enable64kbpages = 1"));
}
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithMixedPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) {
testing::internal::CaptureStdout();
FullyEnabledTestDebugManager debugManager;
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
debugManager.flags.PrintDebugSettings.set(true);
debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::Neo_L0);
debugManager.flags.LoopAtDriverInit.set(true);
debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::Neo);
debugManager.flags.Enable64kbpages.set(1);
debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::None);
debugManager.flags.TbxServer.set("192.168.0.1");
debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::Neo_L0);
// Clear dump files and generate new
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
debugManager.dumpFlags();
// Validate allSettingsDumpFile
SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName};
#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \
{ \
DebugVarPrefix type; \
EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \
}
#include "debug_variables.inl"
#undef DECLARE_DEBUG_VARIABLE
std::remove(FullyEnabledTestDebugManager::settingsDumpFileName);
std::string output = testing::internal::GetCapturedStdout();
ASSERT_NE(0u, output.size());
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_TbxServer = 192.168.0.1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_LoopAtDriverInit = 1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_PrintDebugSettings = 1"));
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: Enable64kbpages = 1"));
}
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledOnDisabledDebugManagerWhenCallingDumpFlagsThenFlagsAreNotWrittenToDumpFile) {
testing::internal::CaptureStdout();
FullyDisabledTestDebugManager debugManager;

407
shared/test/unit_test/os_interface/linux/debug_env_reader.cpp
View File

@@ -7,7 +7,6 @@
#include "shared/source/os_interface/debug_env_reader.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/test/common/helpers/variable_backup.h"
#include "shared/test/common/mocks/mock_io_functions.h"
#include "shared/test/common/test_macros/test.h"
@@ -17,10 +16,6 @@
namespace NEO {
extern ApiSpecificConfig::ApiType apiTypeForUlts;
extern std::vector<const char *> validPrefixes;
extern std::vector<NEO::DebugVarPrefix> validPrefixTypes;
class DebugEnvReaderTests : public ::testing::Test {
public:
void SetUp() override {
@@ -40,6 +35,7 @@ TEST_F(DebugEnvReaderTests, GivenSetVariableThenSetValueIsReturned) {
std::string setString = "Expected Value";
const char *testingVariableName = "TestingVariable";
const char *testingVariableValue = "1234";
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, testingVariableValue}};
@@ -69,407 +65,6 @@ TEST_F(DebugEnvReaderTests, GivenSetVariableThenSetValueIsReturned) {
}
}
TEST_F(DebugEnvReaderTests, GivenSetVariableWithNoPrefixThenSetValueIsReturned) {
int32_t ret;
std::string retString;
std::string defaultString = "Default Value";
std::string setString = "Expected Value";
const char *testingVariableName = "TestingVariable";
const char *testingVariableValue = "1234";
bool defaultBoolValue = true;
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, testingVariableValue}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(3u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::None, type);
EXPECT_EQ(1234, ret);
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, setString.c_str()}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(3u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::None, type);
EXPECT_EQ(0, retString.compare(setString));
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, "0"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, defaultBoolValue, type);
EXPECT_EQ(3u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::None, type);
EXPECT_EQ(0, ret);
}
}
TEST_F(DebugEnvReaderTests, GivenSetVariableWithNeoPrefixThenSetValueIsReturned) {
int32_t ret;
std::string retString;
std::string defaultString = "Default Value";
std::string setString = "Expected Value";
const char *testingVariableName = "TestingVariable";
const char *neoTestingVariableName = "NEO_TestingVariable";
const char *testingVariableValue = "1234";
bool defaultBoolValue = true;
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{neoTestingVariableName, testingVariableValue}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(2u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(1234, ret);
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{neoTestingVariableName, setString.c_str()}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(2u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(0, retString.compare(setString));
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{neoTestingVariableName, "0"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, defaultBoolValue, type);
EXPECT_EQ(2u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(0, ret);
}
}
TEST_F(DebugEnvReaderTests, GivenSetVariableWithOclPrefixThenSetValueIsReturned) {
int32_t ret;
std::string retString;
std::string defaultString = "Default Value";
std::string setString = "Expected Value";
const char *testingVariableName = "TestingVariable";
const char *oclTestingVariableName = "NEO_OCL_TestingVariable";
const char *testingVariableValue = "1234";
bool defaultBoolValue = true;
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::OCL);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{oclTestingVariableName, testingVariableValue}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type);
EXPECT_EQ(1234, ret);
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{oclTestingVariableName, setString.c_str()}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type);
EXPECT_EQ(0, retString.compare(setString));
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{oclTestingVariableName, "0"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, defaultBoolValue, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type);
EXPECT_EQ(0, ret);
}
}
TEST_F(DebugEnvReaderTests, GivenSetVariableWithL0PrefixThenSetValueIsReturned) {
int32_t ret;
std::string retString;
std::string defaultString = "Default Value";
std::string setString = "Expected Value";
const char *testingVariableName = "TestingVariable";
const char *lzeroTestingVariableName = "NEO_L0_TestingVariable";
const char *testingVariableValue = "1234";
bool defaultBoolValue = true;
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{lzeroTestingVariableName, testingVariableValue}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_L0, type);
EXPECT_EQ(1234, ret);
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{lzeroTestingVariableName, setString.c_str()}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_L0, type);
EXPECT_EQ(0, retString.compare(setString));
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{lzeroTestingVariableName, "0"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, defaultBoolValue, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_L0, type);
EXPECT_EQ(0, ret);
}
}
TEST_F(DebugEnvReaderTests, GivenSetVariableWithL0MultiplePrefixesThenHighestPrioritySetValueIsReturned) {
int32_t ret;
std::string retString;
std::string defaultString = "Default Value";
std::string setString = "Expected Value";
const char *testingVariableName = "TestingVariable";
const char *neoTestingVariableName = "NEO_TestingVariable";
const char *lzeroTestingVariableName = "NEO_L0_TestingVariable";
const char *testingVariableValue = "1234";
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, "1"},
{neoTestingVariableName, "2"},
{lzeroTestingVariableName, testingVariableValue}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_L0, type);
EXPECT_EQ(1234, ret);
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, "1"},
{neoTestingVariableName, "2"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(2u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(2, ret);
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, "Default None"},
{neoTestingVariableName, "Default Neo"},
{lzeroTestingVariableName, setString.c_str()}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_L0, type);
EXPECT_EQ(0, retString.compare(setString));
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, "Default None"},
{neoTestingVariableName, "Default Neo"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(2u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(0, retString.compare("Default Neo"));
}
}
TEST_F(DebugEnvReaderTests, GivenSetVariableWithOclMultipPrefixesThenHighestPrioritySetValueIsReturned) {
int32_t ret;
std::string retString;
std::string defaultString = "Default Value";
std::string setString = "Expected Value";
const char *testingVariableName = "TestingVariable";
const char *neoTestingVariableName = "NEO_TestingVariable";
const char *oclTestingVariableName = "NEO_OCL_TestingVariable";
const char *testingVariableValue = "1234";
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::OCL);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, "1"},
{neoTestingVariableName, "2"},
{oclTestingVariableName, testingVariableValue}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type);
EXPECT_EQ(1234, ret);
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, "1"},
{neoTestingVariableName, "2"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(2u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(2, ret);
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, "Default None"},
{neoTestingVariableName, "Default Neo"},
{oclTestingVariableName, setString.c_str()}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type);
EXPECT_EQ(0, retString.compare(setString));
}
{
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{testingVariableName, "Default None"},
{neoTestingVariableName, "Default Neo"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(2u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(0, retString.compare("Default Neo"));
}
}
TEST_F(DebugEnvReaderTests, GivenSetVariableWithBothOclAndL0PrefixCorrectDriverValueReturned) {
int32_t ret;
std::string retString;
std::string defaultString = "Default Value";
std::string setString = "Expected Value";
const char *testingVariableName = "TestingVariable";
const char *lzeroTestingVariableName = "NEO_L0_TestingVariable";
const char *oclTestingVariableName = "NEO_OCL_TestingVariable";
const char *testingVariableValue = "1234";
{
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::OCL);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{lzeroTestingVariableName, "5678"},
{oclTestingVariableName, testingVariableValue}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type);
EXPECT_EQ(1234, ret);
}
{
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{lzeroTestingVariableName, "5678"},
{oclTestingVariableName, testingVariableValue}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
ret = evr->getSetting(testingVariableName, 1, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_L0, type);
EXPECT_EQ(5678, ret);
}
{
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::OCL);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{lzeroTestingVariableName, "Default Level Zero"},
{oclTestingVariableName, setString.c_str()}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type);
EXPECT_EQ(0, retString.compare(setString));
}
{
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
VariableBackup<std::vector<const char *>> validPrefixesBackup(&validPrefixes);
VariableBackup<std::vector<NEO::DebugVarPrefix>> validPrefixTypesBackup(&validPrefixTypes);
validPrefixes.clear();
validPrefixTypes.clear();
ApiSpecificConfig::initPrefixes();
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{lzeroTestingVariableName, "Default Level Zero"},
{oclTestingVariableName, setString.c_str()}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
DebugVarPrefix type = DebugVarPrefix::None;
retString = evr->getSetting("TestingVariable", defaultString, type);
EXPECT_EQ(1u, IoFunctions::mockGetenvCalled);
EXPECT_EQ(DebugVarPrefix::Neo_L0, type);
EXPECT_EQ(0, retString.compare("Default Level Zero"));
}
}
TEST_F(DebugEnvReaderTests, givenMaxInt64AsEnvWhenGetSettingThenProperValueIsReturned) {
const char *testingVariableName = "TestingVariable";
const char *testingVariableValue = "9223372036854775807";

273
shared/test/unit_test/os_interface/windows/registry_reader_tests.cpp
View File

@@ -13,8 +13,6 @@
namespace NEO {
enum class DebugVarPrefix : uint8_t;
using RegistryReaderTest = ::testing::Test;
namespace SysCalls {
@@ -52,15 +50,6 @@ TEST_F(RegistryReaderTest, givenRegistryReaderWhenRegKeyNotExistThenReturnDefaul
EXPECT_EQ(value, registryReader.getSetting("", value));
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenRegKeyNotExistThenReturnDefaultValuePrefix) {
std::string regKey = "notExistPath";
std::string value = "defaultValue";
TestedRegistryReader registryReader(regKey);
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ(value, registryReader.getSetting("", value, type));
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenItIsCreatedWithRegKeySpecifiedThenRegKeyIsInitializedAccordingly) {
std::string regKey = "Software\\Intel\\IGFX\\OCL\\regKey";
TestedRegistryReader registryReader(regKey);
@@ -74,24 +63,6 @@ TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentVariableExistsThenR
EXPECT_EQ("TestedEnvironmentVariableValue", registryReader.getSetting(envVar, value));
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentVariableExistsThenReturnCorrectValuePrefix) {
char *envVar = "TestedEnvironmentVariable";
std::string value = "defaultValue";
TestedRegistryReader registryReader("");
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ("TestedEnvironmentVariableValue", registryReader.getSetting(envVar, value, type));
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenPrefixedEnvironmentVariableExistsThenReturnCorrectValue) {
char *envVar = "TestedEnvironmentVariableWithPrefix";
std::string value = "defaultValue";
TestedRegistryReader registryReader("");
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ("TestedEnvironmentVariableValueWithPrefix", registryReader.getSetting(envVar, value, type));
EXPECT_EQ(DebugVarPrefix::Neo, type);
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentIntVariableExistsThenReturnCorrectValue) {
char *envVar = "TestedEnvironmentIntVariable";
int32_t value = -1;
@@ -99,24 +70,6 @@ TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentIntVariableExistsTh
EXPECT_EQ(1234, registryReader.getSetting(envVar, value));
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentIntVariableExistsThenReturnCorrectValuePrefix) {
char *envVar = "TestedEnvironmentIntVariable";
int32_t value = -1;
TestedRegistryReader registryReader("");
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ(1234, registryReader.getSetting(envVar, value, type));
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenPrefixedEnvironmentIntVariableExistsThenReturnCorrectValue) {
char *envVar = "TestedEnvironmentIntVariableWithPrefix";
int32_t value = -1;
TestedRegistryReader registryReader("");
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ(5678, registryReader.getSetting(envVar, value, type));
EXPECT_EQ(DebugVarPrefix::Neo, type);
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentInt64VariableExistsThenReturnCorrectValue) {
const char *envVar = "TestedEnvironmentInt64Variable";
int64_t expectedValue = 9223372036854775807;
@@ -125,26 +78,6 @@ TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentInt64VariableExists
EXPECT_EQ(expectedValue, registryReader.getSetting(envVar, defaultValue));
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentInt64VariableExistsThenReturnCorrectValuePrefix) {
const char *envVar = "TestedEnvironmentInt64Variable";
int64_t expectedValue = 9223372036854775807;
int64_t defaultValue = 0;
TestedRegistryReader registryReader("");
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ(expectedValue, registryReader.getSetting(envVar, defaultValue, type));
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(RegistryReaderTest, givenRegistryReaderWhenPrefixedEnvironmentInt64VariableExistsThenReturnCorrectValue) {
const char *envVar = "TestedEnvironmentInt64VariableWithPrefix";
int64_t expectedValue = 9223372036854775806;
int64_t defaultValue = 0;
TestedRegistryReader registryReader("");
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ(expectedValue, registryReader.getSetting(envVar, defaultValue, type));
EXPECT_EQ(DebugVarPrefix::Neo, type);
}
struct DebugReaderWithRegistryAndEnvTest : ::testing::Test {
VariableBackup<uint32_t> openRegCountBackup{&SysCalls::regOpenKeySuccessCount};
VariableBackup<uint32_t> queryRegCountBackup{&SysCalls::regQueryValueSuccessCount};
@@ -158,15 +91,6 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenReadFromRegistrySu
EXPECT_EQ(1u, registryReader.getSetting("settingSourceInt", 0));
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValuePrefix) {
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 1u;
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ(1u, registryReader.getSetting("settingSourceInt", 0, type));
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenInt64DebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValue) {
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 1u;
@@ -174,15 +98,6 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenInt64DebugKeyWhenReadFromRegistry
EXPECT_EQ(0xeeeeeeee, registryReader.getSetting("settingSourceInt64", 0));
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenInt64DebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValuePrefix) {
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 1u;
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ(0xeeeeeeee, registryReader.getSetting("settingSourceInt64", 0, type));
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenQueryValueFailsThenObtainValueFromEnv) {
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 0u;
@@ -190,15 +105,6 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenQueryValueFailsThe
EXPECT_EQ(2u, registryReader.getSetting("settingSourceInt", 0));
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenQueryValueFailsThenObtainValueFromEnvPrefix) {
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 0u;
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ(2u, registryReader.getSetting("settingSourceInt", 0, type));
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenOpenKeyFailsThenObtainValueFromEnv) {
SysCalls::regOpenKeySuccessCount = 0u;
SysCalls::regQueryValueSuccessCount = 0u;
@@ -206,15 +112,6 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenOpenKeyFailsThenOb
EXPECT_EQ(2u, registryReader.getSetting("settingSourceInt", 0));
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenOpenKeyFailsThenObtainValueFromEnvPrefix) {
SysCalls::regOpenKeySuccessCount = 0u;
SysCalls::regQueryValueSuccessCount = 0u;
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_EQ(2u, registryReader.getSetting("settingSourceInt", 0, type));
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValue) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 1u;
@@ -223,16 +120,6 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenReadFromRegistr
EXPECT_STREQ("registry", registryReader.getSetting("settingSourceString", defaultValue).c_str());
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValuePrefix) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 2u;
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_STREQ("registry", registryReader.getSetting("settingSourceString", defaultValue, type).c_str());
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenQueryValueFailsThenObtainValueFromEnv) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 1u;
@@ -246,22 +133,6 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenQueryValueFails
EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue).c_str());
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenQueryValueFailsThenObtainValueFromEnvPrefix) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 0u;
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue, type).c_str());
EXPECT_EQ(DebugVarPrefix::None, type);
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 1u;
EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue, type).c_str());
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenOpenKeyFailsThenObtainValueFromEnv) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 0u;
@@ -270,16 +141,6 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenOpenKeyFailsThe
EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue).c_str());
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenOpenKeyFailsThenObtainValueFromEnvPrefix) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 0u;
SysCalls::regQueryValueSuccessCount = 0u;
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue, type).c_str());
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValue) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 1u;
@@ -287,17 +148,6 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyWhenReadFromRegistr
EXPECT_STREQ("registry", registryReader.getSetting("settingSourceBinary", defaultValue).c_str());
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValuePrefix) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 2u;
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_STREQ("registry", registryReader.getSetting("settingSourceBinary", defaultValue, type).c_str());
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyOnlyInRegistryWhenReadFromRegistryFailsThenReturnDefaultValue) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 1u;
@@ -316,28 +166,6 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyOnlyInRegistryWhenR
EXPECT_STREQ("default", registryReader.getSetting("settingSourceBinary", defaultValue).c_str());
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyOnlyInRegistryWhenReadFromRegistryFailsThenReturnDefaultValuePrefix) {
std::string defaultValue("default");
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 1u;
DebugVarPrefix type = DebugVarPrefix::None;
EXPECT_STREQ("default", registryReader.getSetting("settingSourceBinary", defaultValue, type).c_str());
EXPECT_EQ(DebugVarPrefix::None, type);
SysCalls::regOpenKeySuccessCount = 1u;
SysCalls::regQueryValueSuccessCount = 0u;
EXPECT_STREQ("default", registryReader.getSetting("settingSourceBinary", defaultValue, type).c_str());
EXPECT_EQ(DebugVarPrefix::None, type);
SysCalls::regOpenKeySuccessCount = 0u;
SysCalls::regQueryValueSuccessCount = 0u;
EXPECT_STREQ("default", registryReader.getSetting("settingSourceBinary", defaultValue, type).c_str());
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsZeroThenExpectBooleanFalse) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
@@ -352,22 +180,6 @@ TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsZeroThenExpectBoole
EXPECT_FALSE(value);
}
TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsZeroThenExpectBooleanFalsePrefix) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
bool defaultValue = false;
SysCalls::regOpenKeySuccessCount = 1;
SysCalls::regQueryValueSuccessCount = 1;
SysCalls::regQueryValueExpectedData = 0ull;
TestedRegistryReader registryReader(regKey);
DebugVarPrefix type = DebugVarPrefix::None;
bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type);
EXPECT_FALSE(value);
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(RegistryReaderTest, givenRegistryKeyNotPresentWhenDefaulValueIsFalseOrTrueThenExpectReturnIsMatchingFalseOrTrue) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
@@ -390,31 +202,6 @@ TEST_F(RegistryReaderTest, givenRegistryKeyNotPresentWhenDefaulValueIsFalseOrTru
EXPECT_TRUE(value);
}
TEST_F(RegistryReaderTest, givenRegistryKeyNotPresentWhenDefaulValueIsFalseOrTrueThenExpectReturnIsMatchingFalseOrTruePrefix) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
bool defaultValue = false;
SysCalls::regOpenKeySuccessCount = 1;
SysCalls::regQueryValueSuccessCount = 0;
SysCalls::regQueryValueExpectedData = 1ull;
TestedRegistryReader registryReader(regKey);
DebugVarPrefix type = DebugVarPrefix::None;
bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type);
EXPECT_FALSE(value);
EXPECT_EQ(DebugVarPrefix::None, type);
defaultValue = true;
SysCalls::regOpenKeySuccessCount = 1;
SysCalls::regQueryValueSuccessCount = 0;
SysCalls::regQueryValueExpectedData = 0ull;
value = registryReader.getSetting(keyName.c_str(), defaultValue, type);
EXPECT_TRUE(value);
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInHigherDwordThenExpectBooleanFalse) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
@@ -429,22 +216,6 @@ TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInHigherDwor
EXPECT_FALSE(value);
}
TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInHigherDwordThenExpectBooleanFalsePrefix) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
bool defaultValue = true;
SysCalls::regOpenKeySuccessCount = 1;
SysCalls::regQueryValueSuccessCount = 1;
SysCalls::regQueryValueExpectedData = 1ull << 32;
TestedRegistryReader registryReader(regKey);
DebugVarPrefix type = DebugVarPrefix::None;
bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type);
EXPECT_FALSE(value);
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInLowerDwordThenExpectBooleanTrue) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
@@ -459,22 +230,6 @@ TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInLowerDword
EXPECT_TRUE(value);
}
TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInLowerDwordThenExpectBooleanTruePrefix) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
bool defaultValue = false;
SysCalls::regOpenKeySuccessCount = 1;
SysCalls::regQueryValueSuccessCount = 1;
SysCalls::regQueryValueExpectedData = 1ull;
TestedRegistryReader registryReader(regKey);
DebugVarPrefix type = DebugVarPrefix::None;
bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type);
EXPECT_TRUE(value);
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInBothDwordsThenExpectBooleanTrue) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
@@ -489,23 +244,6 @@ TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInBothDwords
EXPECT_TRUE(value);
}
TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInBothDwordsThenExpectBooleanTruePrefix) {
std::string regKey = "notExistPath";
std::string keyName = "boolRegistryKey";
bool defaultValue = false;
SysCalls::regOpenKeySuccessCount = 1;
SysCalls::regQueryValueSuccessCount = 1;
SysCalls::regQueryValueExpectedData = 1ull | (1ull << 32);
TestedRegistryReader registryReader(regKey);
DebugVarPrefix type = DebugVarPrefix::None;
bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type);
EXPECT_TRUE(value);
EXPECT_EQ(DebugVarPrefix::None, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenSetProcessNameWhenReadFromEnvironmentVariableThenReturnClCacheDir) {
SysCalls::regOpenKeySuccessCount = 0u;
SysCalls::regQueryValueSuccessCount = 0u;
@@ -514,15 +252,4 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenSetProcessNameWhenReadFromEnviron
std::string cacheDir = registryReader.getSetting("processName", defaultCacheDir);
EXPECT_STREQ("./tested_cl_cache_dir", cacheDir.c_str());
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenSetProcessNameWhenReadFromEnvironmentVariableThenReturnClCacheDirPrefix) {
SysCalls::regOpenKeySuccessCount = 0u;
SysCalls::regQueryValueSuccessCount = 0u;
registryReader.processName = "processName";
std::string defaultCacheDir = "";
DebugVarPrefix type = DebugVarPrefix::None;
std::string cacheDir2 = registryReader.getSetting("processName", defaultCacheDir, type);
EXPECT_STREQ("./tested_cl_cache_dir", cacheDir2.c_str());
EXPECT_EQ(DebugVarPrefix::None, type);
}
} // namespace NEO

6
shared/test/unit_test/os_interface/windows/registry_reader_tests.h
View File

@@ -24,16 +24,10 @@ class TestedRegistryReader : public RegistryReader {
char *getenv(const char *envVar) override {
if (strcmp(envVar, "TestedEnvironmentVariable") == 0) {
return "TestedEnvironmentVariableValue";
} else if (strcmp(envVar, "NEO_TestedEnvironmentVariableWithPrefix") == 0) {
return "TestedEnvironmentVariableValueWithPrefix";
} else if (strcmp(envVar, "TestedEnvironmentIntVariable") == 0) {
return "1234";
} else if (strcmp(envVar, "NEO_TestedEnvironmentIntVariableWithPrefix") == 0) {
return "5678";
} else if (strcmp(envVar, "TestedEnvironmentInt64Variable") == 0) {
return "9223372036854775807";
} else if (strcmp(envVar, "NEO_TestedEnvironmentInt64VariableWithPrefix") == 0) {
return "9223372036854775806";
} else if (strcmp(envVar, "settingSourceString") == 0) {
return "environment";
} else if (strcmp(envVar, "settingSourceInt") == 0) {

6
shared/test/unit_test/os_interface/windows/wddm_windows_tests.cpp
View File

@@ -5,7 +5,6 @@
*
*/
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/os_interface/windows/driver_info_windows.h"
#include "shared/source/os_interface/windows/dxgi_wrapper.h"
@@ -225,8 +224,6 @@ TEST_F(Wddm20WithMockGdiDllTests, whenSetDeviceInfoSucceedsThenDeviceCallbacksAr
class MockRegistryReaderWithDriverStorePath : public SettingsReader {
public:
MockRegistryReaderWithDriverStorePath(const char *driverStorePathArg) : driverStorePath(driverStorePathArg){};
std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override { return ""; };
std::string getSetting(const char *settingName, const std::string &value) override {
std::string key(settingName);
if (key == "DriverStorePathForComputeRuntime") {
@@ -237,11 +234,8 @@ class MockRegistryReaderWithDriverStorePath : public SettingsReader {
return value;
}
bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override { return defaultValue; };
bool getSetting(const char *settingName, bool defaultValue) override { return defaultValue; };
int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override { return defaultValue; };
int64_t getSetting(const char *settingName, int64_t defaultValue) override { return defaultValue; };
int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) 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(); };

30
shared/test/unit_test/ult_specific_config.cpp
View File

@@ -23,11 +23,6 @@ namespace NEO {
namespace ImplicitScaling {
bool apiSupport = false;
} // namespace ImplicitScaling
const char *neoMockSettingsFileName = "neo_mock.config";
std::vector<const char *> validPrefixes;
std::vector<NEO::DebugVarPrefix> validPrefixTypes;
bool CompressionSelector::preferCompressedAllocation(const AllocationProperties &properties) {
return false;
}
@@ -83,31 +78,6 @@ const char *ApiSpecificConfig::getRegistryPath() {
return "";
}
void ApiSpecificConfig::initPrefixes() {
if (apiTypeForUlts == ApiSpecificConfig::L0) {
validPrefixes.push_back("NEO_L0_");
validPrefixes.push_back("NEO_");
validPrefixes.push_back("");
validPrefixTypes.push_back(DebugVarPrefix::Neo_L0);
validPrefixTypes.push_back(DebugVarPrefix::Neo);
validPrefixTypes.push_back(DebugVarPrefix::None);
} else {
validPrefixes.push_back("NEO_OCL_");
validPrefixes.push_back("NEO_");
validPrefixes.push_back("");
validPrefixTypes.push_back(DebugVarPrefix::Neo_Ocl);
validPrefixTypes.push_back(DebugVarPrefix::Neo);
validPrefixTypes.push_back(DebugVarPrefix::None);
}
}
const std::vector<const char *> &ApiSpecificConfig::getPrefixStrings() {
return validPrefixes;
}
const std::vector<DebugVarPrefix> &ApiSpecificConfig::getPrefixTypes() {
return validPrefixTypes;
}
} // namespace NEO
using namespace NEO;

43
shared/test/unit_test/utilities/debug_file_reader_tests.inl
View File

@@ -5,7 +5,6 @@
*
*/
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/file_io.h"
#include "shared/source/utilities/debug_file_reader.h"
#include "shared/test/common/helpers/test_files.h"
@@ -45,10 +44,6 @@ class TestSettingsFileReader : public SettingsFileReader {
static const std::string getStringTestPath() {
return clFiles + "igdrcl_string.config";
}
static const std::string getNeoStringTestPath() {
return clFiles + "neo_string.config";
}
};
TEST(SettingsFileReader, GivenFilesDoesNotExistWhenCreatingFileReaderThenCreationSucceeds) {
@@ -269,41 +264,3 @@ TEST(SettingsFileReader, givenNoKeyOrNoValueWhenGetSettingThenExceptionIsNotThro
EXPECT_EQ(0u, reader->getStringSettingsCount());
}
}
TEST(SettingsFileReader, givenPrefixFileReadCorrectValueReturned) {
auto reader = std::make_unique<TestSettingsFileReader>(TestSettingsFileReader::getStringTestPath().c_str());
ASSERT_NE(nullptr, reader.get());
DebugVarPrefix type = DebugVarPrefix::None;
int32_t retValue = 0;
int32_t returnedIntValue = reader->getSetting("IntTestKey", retValue, type);
EXPECT_EQ(DebugVarPrefix::None, type);
EXPECT_EQ(123, returnedIntValue);
int32_t returnedIntValueHex = reader->getSetting("IntTestKeyHex", 0, type);
EXPECT_EQ(DebugVarPrefix::None, type);
EXPECT_EQ(0xABCD, returnedIntValueHex);
std::string retValueString = "";
std::string returnedStringValue = reader->getSetting("StringTestKey", retValueString, type);
EXPECT_EQ(DebugVarPrefix::None, type);
EXPECT_STREQ(returnedStringValue.c_str(), "TestValue");
auto neoReader = std::make_unique<TestSettingsFileReader>(TestSettingsFileReader::getNeoStringTestPath().c_str());
ASSERT_NE(nullptr, neoReader.get());
retValue = 0;
returnedIntValue = neoReader->getSetting("IntTestKey", retValue, type);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(123, returnedIntValue);
returnedIntValueHex = neoReader->getSetting("IntTestKeyHex", 0, type);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(0xABCD, returnedIntValueHex);
retValueString = "";
returnedStringValue = "";
returnedStringValue = neoReader->getSetting("StringTestKey", retValueString, type);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_STREQ(returnedStringValue.c_str(), "TestValue");
}

64
shared/test/unit_test/utilities/debug_settings_reader_tests.cpp
View File

@@ -8,7 +8,6 @@
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/helpers/file_io.h"
#include "shared/source/utilities/debug_file_reader.h"
#include "shared/source/utilities/debug_settings_reader.h"
#include "shared/test/common/test_macros/test.h"
@@ -21,29 +20,23 @@ using namespace NEO;
class MockSettingsReader : public SettingsReader {
public:
std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override {
return value;
}
std::string getSetting(const char *settingName, const std::string &value) override {
return value;
}
bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override { return defaultValue; };
bool getSetting(const char *settingName, bool defaultValue) override { return defaultValue; };
int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override { return defaultValue; };
int64_t getSetting(const char *settingName, int64_t defaultValue) override { return defaultValue; };
int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) 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) {
auto reader = std::unique_ptr<SettingsReader>(SettingsReader::create(ApiSpecificConfig::getRegistryPath()));
EXPECT_NE(nullptr, reader.get());
SettingsReader *reader = SettingsReader::create(ApiSpecificConfig::getRegistryPath());
EXPECT_NE(nullptr, reader);
delete reader;
}
TEST(SettingsReader, GivenNoSettingsFileWhenCreatingSettingsReaderThenOsReaderIsCreated) {
ASSERT_FALSE(fileExists(SettingsReader::settingsFileName));
remove(SettingsReader::settingsFileName);
auto fileReader = std::unique_ptr<SettingsReader>(SettingsReader::createFileReader());
EXPECT_EQ(nullptr, fileReader.get());
@@ -52,11 +45,11 @@ TEST(SettingsReader, GivenNoSettingsFileWhenCreatingSettingsReaderThenOsReaderIs
}
TEST(SettingsReader, GivenSettingsFileExistsWhenCreatingSettingsReaderThenReaderIsCreated) {
ASSERT_FALSE(fileExists(SettingsReader::settingsFileName));
const char data[] = "ProductFamilyOverride = test";
writeDataToFile(SettingsReader::settingsFileName, &data, sizeof(data));
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(ApiSpecificConfig::getRegistryPath()));
EXPECT_NE(nullptr, reader.get());
std::string defaultValue("unk");
@@ -66,37 +59,30 @@ TEST(SettingsReader, GivenSettingsFileExistsWhenCreatingSettingsReaderThenReader
}
TEST(SettingsReader, WhenCreatingFileReaderThenReaderIsCreated) {
ASSERT_FALSE(fileExists(SettingsReader::settingsFileName));
char data = 0;
writeDataToFile(SettingsReader::settingsFileName, &data, 0);
bool settingsFileExists = fileExists(SettingsReader::settingsFileName);
if (!settingsFileExists) {
char data = 0;
writeDataToFile(SettingsReader::settingsFileName, &data, 0);
}
SettingsReader *reader = SettingsReader::createFileReader();
EXPECT_NE(nullptr, reader);
auto reader = std::unique_ptr<SettingsReader>(SettingsReader::createFileReader());
EXPECT_NE(nullptr, reader.get());
std::remove(SettingsReader::settingsFileName);
}
TEST(SettingsReader, WhenCreatingFileReaderUseNeoFileIfNoDefault) {
ASSERT_FALSE(fileExists(SettingsReader::settingsFileName));
ASSERT_FALSE(fileExists(SettingsReader::neoSettingsFileName));
char data = 0;
writeDataToFile(SettingsReader::neoSettingsFileName, &data, 0);
auto reader = std::unique_ptr<SettingsReader>(SettingsReader::createFileReader());
EXPECT_NE(nullptr, reader.get());
std::remove(SettingsReader::neoSettingsFileName);
if (!settingsFileExists) {
remove(SettingsReader::settingsFileName);
}
delete reader;
}
TEST(SettingsReader, WhenCreatingOsReaderThenReaderIsCreated) {
auto reader = std::unique_ptr<SettingsReader>(SettingsReader::createOsReader(false, ApiSpecificConfig::getRegistryPath()));
EXPECT_NE(nullptr, reader.get());
SettingsReader *reader = SettingsReader::createOsReader(false, ApiSpecificConfig::getRegistryPath());
EXPECT_NE(nullptr, reader);
delete reader;
}
TEST(SettingsReader, GivenRegKeyWhenCreatingOsReaderThenReaderIsCreated) {
std::string regKey = ApiSpecificConfig::getRegistryPath();
auto reader = std::unique_ptr<SettingsReader>(SettingsReader::createOsReader(false, regKey));
EXPECT_NE(nullptr, reader.get());
std::unique_ptr<SettingsReader> reader(SettingsReader::createOsReader(false, regKey));
EXPECT_NE(nullptr, reader);
}
TEST(SettingsReader, GivenTrueWhenPrintingDebugStringThenPrintsToOutput) {