intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-06 02:18:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "fix: correct loading L0 loader functions"

Browse Source 
This reverts commit 9c7b3c5e19.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2024-10-17 02:39:48 +02:00
committed by Compute-Runtime-Automation
parent e11ceb4a20
commit f117b5fb68
37 changed files with 84 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
shared/test/unit_test/os_interface/linux/os_library_linux_tests.cpp
View File

@@ -34,14 +34,14 @@ TEST(OsLibraryTest, GivenValidNameWhenGettingFullPathAndDlinfoFailsThenPathIsEmp
}
return 0;
});
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
EXPECT_NE(nullptr, library);
std::string path = library->getFullPath();
EXPECT_EQ(0u, path.size());
}
TEST(OsLibraryTest, GivenValidLibNameWhenGettingFullPathThenPathIsNotEmpty) {
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
EXPECT_NE(nullptr, library);
std::string path = library->getFullPath();
EXPECT_NE(0u, path.size());
@@ -59,8 +59,7 @@ TEST(OsLibraryTest, GivenDisableDeepBindFlagWhenOpeningLibraryThenRtldDeepBindFl
VariableBackup<bool> dlOpenCalledBackup{&NEO::SysCalls::dlOpenCalled, false};
debugManager.flags.DisableDeepBind.set(1);
OsLibraryCreateProperties properties("_abc.so");
auto lib = std::make_unique<Linux::OsLibrary>(properties);
auto lib = std::make_unique<Linux::OsLibrary>("_abc.so", nullptr);
EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
EXPECT_EQ(0, NEO::SysCalls::dlOpenFlags & RTLD_DEEPBIND);
}
@@ -69,9 +68,7 @@ TEST(OsLibraryTest, GivenInvalidLibraryWhenOpeningLibraryThenDlopenErrorIsReturn
VariableBackup<bool> dlOpenCalledBackup{&NEO::SysCalls::dlOpenCalled, false};
std::string errorValue;
OsLibraryCreateProperties properties("_abc.so");
properties.errorValue = &errorValue;
auto lib = std::make_unique<Linux::OsLibrary>(properties);
auto lib = std::make_unique<Linux::OsLibrary>("_abc.so", &errorValue);
EXPECT_FALSE(errorValue.empty());
EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
}
@@ -79,33 +76,12 @@ TEST(OsLibraryTest, GivenInvalidLibraryWhenOpeningLibraryThenDlopenErrorIsReturn
TEST(OsLibraryTest, GivenLoadFlagsOverwriteWhenOpeningLibraryThenDlOpenIsCalledWithExpectedFlags) {
VariableBackup<int> dlOpenFlagsBackup{&NEO::SysCalls::dlOpenFlags, 0};
VariableBackup<bool> dlOpenCalledBackup{&NEO::SysCalls::dlOpenCalled, false};
VariableBackup<bool> dlOpenCaptureFileNameBackup{&NEO::SysCalls::captureDlOpenFilePath, true};
auto expectedFlag = RTLD_LAZY | RTLD_GLOBAL;
OsLibraryCreateProperties properties("_abc.so");
properties.customLoadFlags = &expectedFlag;
auto lib = std::make_unique<Linux::OsLibrary>(properties);
NEO::OsLibrary::loadFlagsOverwrite = &expectedFlag;
auto lib = std::make_unique<Linux::OsLibrary>("_abc.so", nullptr);
EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
EXPECT_EQ(NEO::SysCalls::dlOpenFlags, expectedFlag);
EXPECT_EQ(properties.libraryName, NEO::SysCalls::dlOpenFilePathPassed);
}
TEST(OsLibraryTest, WhenPerformSelfOpenThenIgnoreFileNameForDlOpenCall) {
VariableBackup<bool> dlOpenCalledBackup{&NEO::SysCalls::dlOpenCalled, false};
VariableBackup<bool> dlOpenCaptureFileNameBackup{&NEO::SysCalls::captureDlOpenFilePath, true};
OsLibraryCreateProperties properties("_abc.so");
properties.performSelfLoad = false;
auto lib = std::make_unique<Linux::OsLibrary>(properties);
EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
EXPECT_EQ(properties.libraryName, NEO::SysCalls::dlOpenFilePathPassed);
NEO::SysCalls::dlOpenCalled = false;
properties.performSelfLoad = true;
lib = std::make_unique<Linux::OsLibrary>(properties);
EXPECT_TRUE(NEO::SysCalls::dlOpenCalled);
EXPECT_NE(properties.libraryName, NEO::SysCalls::dlOpenFilePathPassed);
EXPECT_TRUE(NEO::SysCalls::dlOpenFilePathPassed.empty());
}
} // namespace NEO

16
shared/test/unit_test/os_interface/os_library_tests.cpp
View File

@@ -22,7 +22,7 @@ const std::string fnName = "testDynamicLibraryFunc";
using namespace NEO;
TEST(OSLibraryTest, whenLibraryNameIsEmptyThenCurrentProcesIsUsedAsLibrary) {
std::unique_ptr<OsLibrary> library{OsLibrary::loadFunc({""})};
std::unique_ptr<OsLibrary> library{OsLibrary::loadFunc("")};
EXPECT_NE(nullptr, library);
void *ptr = library->getProcAddress("selfDynamicLibraryFunc");
EXPECT_NE(nullptr, ptr);
@@ -35,36 +35,32 @@ TEST(OSLibraryTest, GivenFakeLibNameWhenLoadingLibraryThenNullIsReturned) {
TEST(OSLibraryTest, GivenFakeLibNameWhenLoadingLibraryThenNullIsReturnedAndErrorString) {
std::string errorValue;
OsLibraryCreateProperties properties(fakeLibName);
properties.errorValue = &errorValue;
OsLibrary *library = OsLibrary::loadFunc(properties);
OsLibrary *library = OsLibrary::loadAndCaptureError(fakeLibName, &errorValue);
EXPECT_FALSE(errorValue.empty());
EXPECT_EQ(nullptr, library);
}
TEST(OSLibraryTest, GivenValidLibNameWhenLoadingLibraryThenLibraryIsLoaded) {
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
EXPECT_NE(nullptr, library);
}
TEST(OSLibraryTest, GivenValidLibNameWhenLoadingLibraryThenLibraryIsLoadedWithNoErrorString) {
std::string errorValue;
OsLibraryCreateProperties properties(Os::testDllName);
properties.errorValue = &errorValue;
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(properties));
std::unique_ptr<OsLibrary> library(OsLibrary::loadAndCaptureError(Os::testDllName, &errorValue));
EXPECT_TRUE(errorValue.empty());
EXPECT_NE(nullptr, library);
}
TEST(OSLibraryTest, whenSymbolNameIsValidThenGetProcAddressReturnsNonNullPointer) {
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
EXPECT_NE(nullptr, library);
void *ptr = library->getProcAddress(fnName);
EXPECT_NE(nullptr, ptr);
}
TEST(OSLibraryTest, whenSymbolNameIsInvalidThenGetProcAddressReturnsNullPointer) {
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
EXPECT_NE(nullptr, library);
void *ptr = library->getProcAddress(fnName + "invalid");
EXPECT_EQ(nullptr, ptr);

37
shared/test/unit_test/os_interface/windows/os_library_win_tests.cpp
View File

@@ -20,10 +20,6 @@ extern const char *testDllName;
using namespace NEO;
class OsLibraryBackup : public Windows::OsLibrary {
public:
using Windows::OsLibrary::getModuleHandleA;
using Windows::OsLibrary::loadLibraryExA;
using Type = decltype(Windows::OsLibrary::loadLibraryExA);
using BackupType = VariableBackup<Type>;
@@ -39,6 +35,7 @@ class OsLibraryBackup : public Windows::OsLibrary {
std::unique_ptr<SystemDirectoryBackupType> bkp3 = nullptr;
};
public:
static std::unique_ptr<Backup> backup(Type newValue, ModuleNameType newModuleName, SystemDirectoryType newSystemDirectoryName) {
std::unique_ptr<Backup> bkp(new Backup());
bkp->bkp1.reset(new BackupType(&OsLibrary::loadLibraryExA, newValue));
@@ -87,7 +84,7 @@ UINT WINAPI getSystemDirectoryAMock(LPSTR lpBuffer, UINT uSize) {
TEST(OSLibraryWinTest, WhenLoadDependencyFailsThenFallbackToSystem32) {
auto bkp = OsLibraryBackup::backup(loadLibraryExAMock, getModuleFileNameAMock, getSystemDirectoryAMock);
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
EXPECT_NE(nullptr, library);
}
@@ -95,7 +92,7 @@ TEST(OSLibraryWinTest, WhenDependencyLoadsThenProperPathIsConstructed) {
auto bkp = OsLibraryBackup::backup(loadLibraryExAMock, getModuleFileNameAMock, getSystemDirectoryAMock);
VariableBackup<bool> bkpM(&mockWillFailInNonSystem32, false);
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc({Os::testDllName}));
std::unique_ptr<OsLibrary> library(OsLibrary::loadFunc(Os::testDllName));
EXPECT_NE(nullptr, library);
}
@@ -109,41 +106,17 @@ TEST(OSLibraryWinTest, WhenCreatingFullSystemPathThenProperPathIsConstructed) {
TEST(OSLibraryWinTest, GivenInvalidLibraryWhenOpeningLibraryThenLoadLibraryErrorIsReturned) {
std::string errorValue;
OsLibraryCreateProperties properties("abc");
properties.errorValue = &errorValue;
auto lib = std::make_unique<Windows::OsLibrary>(properties);
auto lib = std::make_unique<Windows::OsLibrary>("abc", &errorValue);
EXPECT_FALSE(errorValue.empty());
}
TEST(OSLibraryWinTest, GivenNoLastErrorOnWindowsThenErrorStringisEmpty) {
std::string errorValue;
OsLibraryCreateProperties properties(Os::testDllName);
properties.errorValue = &errorValue;
auto lib = std::make_unique<Windows::OsLibrary>(properties);
auto lib = std::make_unique<Windows::OsLibrary>(Os::testDllName, &errorValue);
EXPECT_NE(nullptr, lib);
EXPECT_TRUE(errorValue.empty());
lib->getLastErrorString(&errorValue);
EXPECT_TRUE(errorValue.empty());
lib->getLastErrorString(nullptr);
}
TEST(OSLibraryWinTest, WhenCreateOsLibraryWithSelfOpenThenDontLoadLibrary) {
OsLibraryCreateProperties properties(Os::testDllName);
VariableBackup<decltype(OsLibraryBackup::loadLibraryExA)> backupLoadLibrary(&OsLibraryBackup::loadLibraryExA, [](LPCSTR, HANDLE, DWORD) -> HMODULE {
UNRECOVERABLE_IF(true);
return nullptr;
});
VariableBackup<decltype(OsLibraryBackup::getModuleHandleA)> backupGetModuleHandle(&OsLibraryBackup::getModuleHandleA, [](LPCSTR moduleName) -> HMODULE {
return nullptr;
});
properties.performSelfLoad = true;
auto lib = std::make_unique<Windows::OsLibrary>(properties);
EXPECT_FALSE(lib->isLoaded());
OsLibraryBackup::getModuleHandleA = [](LPCSTR moduleName) -> HMODULE {
return reinterpret_cast<HMODULE>(0x1000);
};
lib = std::make_unique<Windows::OsLibrary>(properties);
EXPECT_TRUE(lib->isLoaded());
}