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

feature: Add debug/release variables prefixes

Browse Source 
Add debug/release variables with prefixes for Level Zero, OpenCL and NEO

Resolves: NEO-6357

Signed-off-by: John Falkowski <john.falkowski@intel.com>
This commit is contained in:
John Falkowski
2023-08-20 04:31:48 +00:00
committed by Compute-Runtime-Automation
parent 3d33366ff6
commit d49190f4ae
23 changed files with 1289 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -10,7 +10,12 @@
#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;
}
@@ -51,4 +56,16 @@ const char *ApiSpecificConfig::getRegistryPath() {
return L0::registryPath;
}
void ApiSpecificConfig::initPrefixes() {
validL0Prefixes = {"NEO_L0_", "NEO_", ""};
validL0PrefixTypes = {DebugVarPrefix::Neo_L0, DebugVarPrefix::Neo, DebugVarPrefix::None};
}
const std::vector<const char *> &ApiSpecificConfig::getPrefixStrings() {
return validL0Prefixes;
}
const std::vector<DebugVarPrefix> &ApiSpecificConfig::getPrefixTypes() {
return validL0PrefixTypes;
}
} // namespace NEO

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

@@ -10,7 +10,12 @@
#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;
}
@@ -50,4 +55,17 @@ uint64_t ApiSpecificConfig::getReducedMaxAllocSize(uint64_t maxAllocSize) {
const char *ApiSpecificConfig::getRegistryPath() {
return oclRegPath;
}
void ApiSpecificConfig::initPrefixes() {
validClPrefixes = {"NEO_OCL_", "NEO_", ""};
validClPrefixTypes = {DebugVarPrefix::Neo_Ocl, DebugVarPrefix::Neo, 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,6 +6,7 @@
*/
#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"
@@ -110,6 +111,8 @@ 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") {
@@ -131,8 +134,11 @@ 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,9 +9,11 @@
#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>
@@ -33,6 +35,7 @@ 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);
@@ -57,6 +60,18 @@ 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) {
@@ -74,18 +89,31 @@ void DebugSettingsManager<DebugLevel>::getStringWithFlags(std::string &allFlags,
std::ostringstream changedFlagsStream;
changedFlagsStream.str("");
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
allFlagsStream << getNonReleaseKeyName(#variableName) << " = " << flags.variableName.get() << '\n'; \
dumpNonDefaultFlag<dataType>(getNonReleaseKeyName(#variableName), flags.variableName.get(), defaultValue, changedFlagsStream);
#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); \
}
if (registryReadAvailable() || isDebugKeysReadEnabled()) {
#include "debug_variables.inl"
}
#undef DECLARE_DEBUG_VARIABLE
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
allFlagsStream << #variableName << " = " << flags.variableName.get() << '\n'; \
dumpNonDefaultFlag<dataType>(#variableName, flags.variableName.get(), defaultValue, changedFlagsStream);
#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); \
}
#include "release_variables.inl"
#undef DECLARE_DEBUG_VARIABLE
@@ -114,10 +142,12 @@ void DebugSettingsManager<DebugLevel>::dumpFlags() const {
template <DebugFunctionalityLevel DebugLevel>
void DebugSettingsManager<DebugLevel>::injectSettingsFromReader() {
#undef DECLARE_DEBUG_VARIABLE
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
{ \
dataType tempData = readerImpl->getSetting(getNonReleaseKeyName(#variableName), flags.variableName.get()); \
flags.variableName.set(tempData); \
#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); \
}
if (registryReadAvailable() || isDebugKeysReadEnabled()) {
@@ -125,10 +155,12 @@ void DebugSettingsManager<DebugLevel>::injectSettingsFromReader() {
}
#undef DECLARE_DEBUG_VARIABLE
#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \
{ \
dataType tempData = readerImpl->getSetting(#variableName, flags.variableName.get()); \
flags.variableName.set(tempData); \
#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); \
}
#include "release_variables.inl"
#undef DECLARE_DEBUG_VARIABLE

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

@@ -59,6 +59,13 @@ 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) {}
@@ -76,10 +83,17 @@ 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)
@@ -158,6 +172,8 @@ class DebugSettingsManager {
extern DebugSettingsManager<globalDebugFunctionalityLevel> DebugManager;
#define MAX_NEO_KEY_LENGTH 256
#define PRINT_DEBUGGER_LOG_TO_FILE(...) \
NEO::DebugManager.logLazyEvaluateArgs([&] { \
char temp[4000]; \

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

@@ -6,10 +6,14 @@
*/
#pragma once
#include "shared/source/debug_settings/debug_settings_manager.h"
#include <cstdint>
#include <string>
#include <vector>
namespace NEO {
struct ApiSpecificConfig {
enum ApiType { OCL,
L0 };
@@ -22,7 +26,9 @@ struct ApiSpecificConfig {
static std::string getName();
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,22 +7,57 @@
#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;
@@ -34,6 +69,31 @@ 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,9 +14,13 @@ 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,6 +8,7 @@
#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"
@@ -43,19 +44,26 @@ 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)));
}
int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue) {
bool RegistryReader::getSettingIntCommon(const char *settingName, int64_t &value) {
HKEY Key{};
int64_t value = defaultValue;
DWORD success = ERROR_SUCCESS;
bool readSettingFromEnv = true;
bool retVal = false;
success = SysCalls::regOpenKeyExA(hkeyType,
registryReadRootKey.c_str(),
@@ -75,11 +83,44 @@ int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue
&size);
if (ERROR_SUCCESS == success) {
value = regData;
readSettingFromEnv = false;
retVal = true;
}
RegCloseKey(Key);
}
if (readSettingFromEnv) {
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))) {
const char *envValue = getenv(settingName);
if (envValue) {
value = atoll(envValue);
@@ -89,11 +130,10 @@ int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue
return value;
}
std::string RegistryReader::getSetting(const char *settingName, const std::string &value) {
bool RegistryReader::getSettingStringCommon(const char *settingName, std::string &keyValue) {
HKEY Key{};
DWORD success = ERROR_SUCCESS;
std::string keyValue = value;
bool readSettingFromEnv = true;
bool retVal = false;
success = SysCalls::regOpenKeyExA(hkeyType,
registryReadRootKey.c_str(),
@@ -121,7 +161,7 @@ std::string RegistryReader::getSetting(const char *settingName, const std::strin
&regSize);
if (success == ERROR_SUCCESS) {
keyValue.assign(regData.get());
readSettingFromEnv = false;
retVal = true;
}
} else if (regType == REG_BINARY) {
size_t charCount = regSize / sizeof(wchar_t);
@@ -140,14 +180,46 @@ std::string RegistryReader::getSetting(const char *settingName, const std::strin
convertedData.get()[charCount] = 0;
keyValue.assign(convertedData.get());
readSettingFromEnv = false;
retVal = true;
}
}
}
RegCloseKey(Key);
}
return retVal;
}
if (readSettingFromEnv) {
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))) {
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,13 +15,22 @@
#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,6 +7,7 @@
#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>
@@ -30,10 +31,37 @@ 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;
@@ -45,10 +73,37 @@ 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,13 +15,19 @@
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,17 +10,24 @@
#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;
settingsFile.open(settingsFileName);
if (settingsFile.is_open()) {
settingsFile.close();
return new SettingsFileReader(settingsFileName);
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);
}
}
return nullptr;
}

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

@@ -11,6 +11,8 @@
namespace NEO {
enum class DebugVarPrefix : uint8_t;
class SettingsReader {
public:
virtual ~SettingsReader() = default;
@@ -23,12 +25,17 @@ 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 Normal file
View File

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

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

@@ -5,6 +5,7 @@
*
*/
#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"
@@ -21,6 +22,10 @@
#include <sstream>
#include <string>
namespace NEO {
extern ApiSpecificConfig::ApiType apiTypeForUlts;
} // namespace NEO
TEST(DebugSettingsManager, WhenDebugManagerIsCreatedThenInjectFcnIsNull) {
FullyEnabledTestDebugManager debugManager;
@@ -114,13 +119,19 @@ TEST(DebugSettingsManager, givenReaderImplInDebugManagerWhenSettingDifferentRead
EXPECT_EQ(readerImpl2, debugManager.getReaderImpl());
}
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) {
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithNoPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) {
testing::internal::CaptureStdout();
FullyEnabledTestDebugManager debugManager;
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
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);
@@ -128,11 +139,15 @@ TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWhenCallingDumpFlagsThe
// Validate allSettingsDumpFile
SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName};
#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \
EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue));
#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());
@@ -143,6 +158,162 @@ TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWhenCallingDumpFlagsThe
EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: Enable64kbpages = 1"));
}
TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithNeoPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) {
testing::internal::CaptureStdout();
FullyEnabledTestDebugManager debugManager;
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
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);
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);
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);
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;

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

@@ -7,6 +7,7 @@
#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"
@@ -16,6 +17,8 @@
namespace NEO {
extern ApiSpecificConfig::ApiType apiTypeForUlts;
class DebugEnvReaderTests : public ::testing::Test {
public:
void SetUp() override {
@@ -65,6 +68,366 @@ 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<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
{
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<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::L0);
{
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<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<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<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<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<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<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<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<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,6 +13,8 @@
namespace NEO {
enum class DebugVarPrefix : uint8_t;
using RegistryReaderTest = ::testing::Test;
namespace SysCalls {
@@ -50,6 +52,15 @@ 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);
@@ -63,6 +74,24 @@ 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;
@@ -70,6 +99,24 @@ 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;
@@ -78,6 +125,26 @@ 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};
@@ -91,6 +158,15 @@ 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;
@@ -98,6 +174,15 @@ 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;
@@ -105,6 +190,15 @@ 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;
@@ -112,6 +206,15 @@ 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;
@@ -120,6 +223,16 @@ 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;
@@ -133,6 +246,22 @@ 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;
@@ -141,6 +270,16 @@ 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;
@@ -148,6 +287,17 @@ 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;
@@ -166,6 +316,28 @@ 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";
@@ -180,6 +352,22 @@ 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";
@@ -202,6 +390,31 @@ 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";
@@ -216,6 +429,22 @@ 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";
@@ -230,6 +459,22 @@ 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";
@@ -244,6 +489,23 @@ 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;
@@ -252,4 +514,15 @@ 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,10 +24,16 @@ 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,6 +5,7 @@
*
*/
#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"
@@ -224,6 +225,8 @@ 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") {
@@ -234,8 +237,11 @@ 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(); };

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

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

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

@@ -5,9 +5,12 @@
*
*/
#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/test/common/helpers/test_files.h"
#include "shared/test/common/helpers/variable_backup.h"
#include "shared/test/common/test_macros/test.h"
#include "gtest/gtest.h"
@@ -15,6 +18,10 @@
#include <memory>
#include <string>
namespace NEO {
extern ApiSpecificConfig::ApiType apiTypeForUlts;
} // namespace NEO
using namespace NEO;
class TestSettingsFileReader : public SettingsFileReader {
@@ -44,6 +51,10 @@ 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) {
@@ -264,3 +275,43 @@ 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());
VariableBackup<ApiSpecificConfig::ApiType> backup(&apiTypeForUlts, ApiSpecificConfig::OCL);
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 neo_reader = std::make_unique<TestSettingsFileReader>(TestSettingsFileReader::getNeoStringTestPath().c_str());
ASSERT_NE(nullptr, neo_reader.get());
retValue = 0;
returnedIntValue = 0;
returnedIntValue = neo_reader->getSetting("IntTestKey", retValue, type);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(123, returnedIntValue);
returnedIntValueHex = 0;
returnedIntValueHex = neo_reader->getSetting("IntTestKeyHex", 0, type);
EXPECT_EQ(DebugVarPrefix::Neo, type);
EXPECT_EQ(0xABCD, returnedIntValueHex);
retValueString = "";
returnedStringValue = "";
returnedStringValue = neo_reader->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,6 +8,7 @@
#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"
@@ -20,23 +21,29 @@ 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) {
SettingsReader *reader = SettingsReader::create(ApiSpecificConfig::getRegistryPath());
EXPECT_NE(nullptr, reader);
delete reader;
auto reader = std::unique_ptr<SettingsReader>(SettingsReader::create(ApiSpecificConfig::getRegistryPath()));
EXPECT_NE(nullptr, reader.get());
}
TEST(SettingsReader, GivenNoSettingsFileWhenCreatingSettingsReaderThenOsReaderIsCreated) {
remove(SettingsReader::settingsFileName);
ASSERT_FALSE(fileExists(SettingsReader::settingsFileName));
auto fileReader = std::unique_ptr<SettingsReader>(SettingsReader::createFileReader());
EXPECT_EQ(nullptr, fileReader.get());
@@ -45,11 +52,11 @@ TEST(SettingsReader, GivenNoSettingsFileWhenCreatingSettingsReaderThenOsReaderIs
}
TEST(SettingsReader, GivenSettingsFileExistsWhenCreatingSettingsReaderThenReaderIsCreated) {
bool settingsFileExists = fileExists(SettingsReader::settingsFileName);
if (!settingsFileExists) {
const char data[] = "ProductFamilyOverride = test";
writeDataToFile(SettingsReader::settingsFileName, &data, sizeof(data));
}
ASSERT_FALSE(fileExists(SettingsReader::settingsFileName));
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");
@@ -59,30 +66,37 @@ TEST(SettingsReader, GivenSettingsFileExistsWhenCreatingSettingsReaderThenReader
}
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);
ASSERT_FALSE(fileExists(SettingsReader::settingsFileName));
char data = 0;
writeDataToFile(SettingsReader::settingsFileName, &data, 0);
if (!settingsFileExists) {
remove(SettingsReader::settingsFileName);
}
delete 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);
}
TEST(SettingsReader, WhenCreatingOsReaderThenReaderIsCreated) {
SettingsReader *reader = SettingsReader::createOsReader(false, ApiSpecificConfig::getRegistryPath());
EXPECT_NE(nullptr, reader);
delete reader;
auto reader = std::unique_ptr<SettingsReader>(SettingsReader::createOsReader(false, ApiSpecificConfig::getRegistryPath()));
EXPECT_NE(nullptr, reader.get());
}
TEST(SettingsReader, GivenRegKeyWhenCreatingOsReaderThenReaderIsCreated) {
std::string regKey = ApiSpecificConfig::getRegistryPath();
std::unique_ptr<SettingsReader> reader(SettingsReader::createOsReader(false, regKey));
EXPECT_NE(nullptr, reader);
auto reader = std::unique_ptr<SettingsReader>(SettingsReader::createOsReader(false, regKey));
EXPECT_NE(nullptr, reader.get());
}
TEST(SettingsReader, GivenTrueWhenPrintingDebugStringThenPrintsToOutput) {