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

Refactor ULT, dont create parameterized tests for single config tests

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2020-12-02 12:43:54 +00:00
committed by Compute-Runtime-Automation
parent cb14f0969d
commit ff027615c9
12 changed files with 130 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
opencl/test/unit_test/device_queue/device_queue_hw_tests.cpp
View File

@ -480,12 +480,13 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueHwTest, WhenCreatingDeviceQueueThenDshOff
delete deviceQueue;
}
class DeviceQueueHwWithKernel : public ExecutionModelKernelFixture {
class DeviceQueueHwWithKernel : public ExecutionModelKernelFixture,
public ::testing::WithParamInterface<std::tuple<const char *, const char *>> {
public:
void SetUp() override {
REQUIRE_DEVICE_ENQUEUE_OR_SKIP(defaultHwInfo);
ExecutionModelKernelFixture::SetUp();
ExecutionModelKernelFixture::SetUp(std::get<0>(GetParam()), std::get<1>(GetParam()));
cl_queue_properties properties[5] = {
CL_QUEUE_PROPERTIES,
CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,

5
opencl/test/unit_test/fixtures/execution_model_fixture.h
View File

@ -50,13 +50,14 @@ class DeviceQueueFixture {
class ExecutionModelKernelTest : public ExecutionModelKernelFixture,
public CommandQueueHwFixture,
public DeviceQueueFixture {
public DeviceQueueFixture,
public ::testing::WithParamInterface<std::tuple<const char *, const char *>> {
public:
void SetUp() override {
REQUIRE_DEVICE_ENQUEUE_OR_SKIP(defaultHwInfo);
DebugManager.flags.EnableTimestampPacket.set(0);
ExecutionModelKernelFixture::SetUp();
ExecutionModelKernelFixture::SetUp(std::get<0>(GetParam()), std::get<1>(GetParam()));
CommandQueueHwFixture::SetUp(pClDevice, 0);
DeviceQueueFixture::SetUp(context, pClDevice);
}

12
opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h
View File

@ -16,17 +16,17 @@
using namespace NEO;
class ExecutionModelKernelFixture : public ProgramFromBinaryTest,
public PlatformFixture {
protected:
void SetUp() override {
struct ExecutionModelKernelFixture : public ProgramFromBinaryFixture,
public PlatformFixture {
using ProgramFromBinaryFixture::SetUp;
void SetUp(const char *binaryFileName, const char *kernelName) {
REQUIRE_DEVICE_ENQUEUE_OR_SKIP(defaultHwInfo);
PlatformFixture::SetUp();
std::string options("-cl-std=CL2.0");
this->setOptions(options);
ProgramFromBinaryTest::SetUp();
ProgramFromBinaryFixture::SetUp(binaryFileName, kernelName);
ASSERT_NE(nullptr, pProgram);
ASSERT_EQ(CL_SUCCESS, retVal);
@ -55,7 +55,7 @@ class ExecutionModelKernelFixture : public ProgramFromBinaryTest,
pKernel->release();
}
ProgramFromBinaryTest::TearDown();
ProgramFromBinaryFixture::TearDown();
PlatformFixture::TearDown();
if (pDevice != nullptr) {

8
opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
View File

@ -1068,8 +1068,14 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, GivenKernelWithSamplersWhenInd
delete[] mockDsh;
}
typedef ExecutionModelKernelFixture ParentKernelCommandsFromBinaryTest;
struct ParentKernelCommandsFromBinaryTest : public ExecutionModelKernelFixture,
public ::testing::WithParamInterface<std::tuple<const char *, const char *>> {
void SetUp() override {
ExecutionModelKernelFixture::SetUp(std::get<0>(GetParam()), std::get<1>(GetParam()));
}
};
HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelCommandsFromBinaryTest, WhenGettingSizeRequiredForExecutionModelForSurfaceStatesThenReturnSizeOfBlocksPlusMaxBindingTableSizeForAllIdtEntriesAndSchedulerSshSize) {
using BINDING_TABLE_STATE = typename FamilyType::BINDING_TABLE_STATE;

21
opencl/test/unit_test/kernel/kernel_arg_info_tests.cpp
View File

@ -86,12 +86,12 @@ class KernelArgInfoTest : public ProgramFromSourceTest {
KernelBinaryHelper *kbHelper = nullptr;
};
TEST_P(KernelArgInfoTest, GivenNullWhenGettingKernelInfoThenNullIsReturned) {
TEST_F(KernelArgInfoTest, GivenNullWhenGettingKernelInfoThenNullIsReturned) {
auto kernelInfo = this->pProgram->getKernelInfo(nullptr, 0);
EXPECT_EQ(nullptr, kernelInfo);
}
TEST_P(KernelArgInfoTest, GivenInvalidParametersWhenGettingKernelArgInfoThenValueSizeRetIsNotUpdated) {
TEST_F(KernelArgInfoTest, GivenInvalidParametersWhenGettingKernelArgInfoThenValueSizeRetIsNotUpdated) {
size_t paramValueSizeRet = 0x1234;
retVal = pKernel->getArgInfo(
@ -104,25 +104,25 @@ TEST_P(KernelArgInfoTest, GivenInvalidParametersWhenGettingKernelArgInfoThenValu
EXPECT_EQ(0x1234u, paramValueSizeRet);
}
TEST_P(KernelArgInfoTest, GivenKernelArgAccessQualifierWhenQueryingArgInfoThenKernelArgAcessNoneIsReturned) {
TEST_F(KernelArgInfoTest, GivenKernelArgAccessQualifierWhenQueryingArgInfoThenKernelArgAcessNoneIsReturned) {
cl_kernel_arg_access_qualifier param_value = 0;
queryArgInfo<cl_kernel_arg_access_qualifier>(CL_KERNEL_ARG_ACCESS_QUALIFIER, param_value);
EXPECT_EQ(static_cast<cl_kernel_arg_access_qualifier>(CL_KERNEL_ARG_ACCESS_NONE), param_value);
}
TEST_P(KernelArgInfoTest, GivenKernelArgAddressQualifierWhenQueryingArgInfoThenKernelArgAddressGlobalIsReturned) {
TEST_F(KernelArgInfoTest, GivenKernelArgAddressQualifierWhenQueryingArgInfoThenKernelArgAddressGlobalIsReturned) {
cl_kernel_arg_address_qualifier param_value = 0;
queryArgInfo<cl_kernel_arg_address_qualifier>(CL_KERNEL_ARG_ADDRESS_QUALIFIER, param_value);
EXPECT_EQ(static_cast<cl_kernel_arg_address_qualifier>(CL_KERNEL_ARG_ADDRESS_GLOBAL), param_value);
}
TEST_P(KernelArgInfoTest, GivenKernelArgTypeQualifierWhenQueryingArgInfoThenKernelArgTypeNoneIsReturned) {
TEST_F(KernelArgInfoTest, GivenKernelArgTypeQualifierWhenQueryingArgInfoThenKernelArgTypeNoneIsReturned) {
cl_kernel_arg_type_qualifier param_value = 0;
queryArgInfo<cl_kernel_arg_type_qualifier>(CL_KERNEL_ARG_TYPE_QUALIFIER, param_value);
EXPECT_EQ(static_cast<cl_kernel_arg_type_qualifier>(CL_KERNEL_ARG_TYPE_NONE), param_value);
}
TEST_P(KernelArgInfoTest, GivenParamWhenGettingKernelTypeNameThenCorrectValueIsReturned) {
TEST_F(KernelArgInfoTest, GivenParamWhenGettingKernelTypeNameThenCorrectValueIsReturned) {
cl_kernel_arg_info paramName = CL_KERNEL_ARG_TYPE_NAME;
char *paramValue = nullptr;
size_t paramValueSize = 0;
@ -157,7 +157,7 @@ TEST_P(KernelArgInfoTest, GivenParamWhenGettingKernelTypeNameThenCorrectValueIsR
delete[] paramValue;
}
TEST_P(KernelArgInfoTest, GivenParamWhenGettingKernelArgNameThenCorrectValueIsReturned) {
TEST_F(KernelArgInfoTest, GivenParamWhenGettingKernelArgNameThenCorrectValueIsReturned) {
cl_kernel_arg_info paramName = CL_KERNEL_ARG_NAME;
char *paramValue = nullptr;
size_t paramValueSize = 0;
@ -189,10 +189,3 @@ TEST_P(KernelArgInfoTest, GivenParamWhenGettingKernelArgNameThenCorrectValueIsRe
EXPECT_EQ(0, strcmp(paramValue, "src"));
delete[] paramValue;
}
INSTANTIATE_TEST_CASE_P(KernelArgInfoTests,
KernelArgInfoTest,
::testing::Combine(
::testing::ValuesIn(SourceFileNames),
::testing::ValuesIn(BinaryForSourceFileNames),
::testing::ValuesIn(KernelNames)));

9
opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp
View File

@ -33,7 +33,14 @@
using namespace NEO;
typedef ExecutionModelKernelFixture KernelReflectionSurfaceTest;
struct KernelReflectionSurfaceTest : public ExecutionModelKernelFixture,
public ::testing::WithParamInterface<std::tuple<const char *, const char *>> {
void SetUp() override {
ExecutionModelKernelFixture::SetUp(std::get<0>(GetParam()), std::get<1>(GetParam()));
}
};
typedef ExecutionModelKernelTest KernelReflectionSurfaceWithQueueTest;
TEST_P(KernelReflectionSurfaceTest, WhenCreatingKernelThenKernelReflectionSurfaceIsNull) {

38
opencl/test/unit_test/kernel/kernel_tests.cpp
View File

@ -48,13 +48,13 @@
using namespace NEO;
using namespace DeviceHostQueue;
class KernelTest : public ProgramFromBinaryTest {
class KernelTests : public ProgramFromBinaryFixture {
public:
~KernelTest() override = default;
~KernelTests() override = default;
protected:
void SetUp() override {
ProgramFromBinaryTest::SetUp();
ProgramFromBinaryFixture::SetUp("CopyBuffer_simd32", "CopyBuffer");
ASSERT_NE(nullptr, pProgram);
ASSERT_EQ(CL_SUCCESS, retVal);
@ -78,7 +78,7 @@ class KernelTest : public ProgramFromBinaryTest {
delete pKernel;
pKernel = nullptr;
knownSource.reset();
ProgramFromBinaryTest::TearDown();
ProgramFromBinaryFixture::TearDown();
}
Kernel *pKernel = nullptr;
@ -96,12 +96,12 @@ TEST(KernelTest, WhenKernelIsCreatedThenCorrectMembersAreMemObjects) {
EXPECT_FALSE(Kernel::isMemObj(Kernel::SVM_ALLOC_OBJ));
}
TEST_P(KernelTest, WhenKernelIsCreatedThenKernelHeapIsCorrect) {
TEST_F(KernelTests, WhenKernelIsCreatedThenKernelHeapIsCorrect) {
EXPECT_EQ(pKernel->getKernelInfo().heapInfo.pKernelHeap, pKernel->getKernelHeap());
EXPECT_EQ(pKernel->getKernelInfo().heapInfo.KernelHeapSize, pKernel->getKernelHeapSize());
}
TEST_P(KernelTest, GivenInvalidParamNameWhenGettingInfoThenInvalidValueErrorIsReturned) {
TEST_F(KernelTests, GivenInvalidParamNameWhenGettingInfoThenInvalidValueErrorIsReturned) {
size_t paramValueSizeRet = 0;
// get size
@ -114,7 +114,7 @@ TEST_P(KernelTest, GivenInvalidParamNameWhenGettingInfoThenInvalidValueErrorIsRe
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_P(KernelTest, GivenInvalidParametersWhenGettingInfoThenValueSizeRetIsNotUpdated) {
TEST_F(KernelTests, GivenInvalidParametersWhenGettingInfoThenValueSizeRetIsNotUpdated) {
size_t paramValueSizeRet = 0x1234;
// get size
@ -128,7 +128,7 @@ TEST_P(KernelTest, GivenInvalidParametersWhenGettingInfoThenValueSizeRetIsNotUpd
EXPECT_EQ(0x1234u, paramValueSizeRet);
}
TEST_P(KernelTest, GivenKernelFunctionNameWhenGettingInfoThenKernelFunctionNameIsReturned) {
TEST_F(KernelTests, GivenKernelFunctionNameWhenGettingInfoThenKernelFunctionNameIsReturned) {
cl_kernel_info paramName = CL_KERNEL_FUNCTION_NAME;
size_t paramValueSize = 0;
char *paramValue = nullptr;
@ -162,7 +162,7 @@ TEST_P(KernelTest, GivenKernelFunctionNameWhenGettingInfoThenKernelFunctionNameI
delete[] paramValue;
}
TEST_P(KernelTest, GivenKernelBinaryProgramIntelWhenGettingInfoThenKernelBinaryIsReturned) {
TEST_F(KernelTests, GivenKernelBinaryProgramIntelWhenGettingInfoThenKernelBinaryIsReturned) {
cl_kernel_info paramName = CL_KERNEL_BINARY_PROGRAM_INTEL;
size_t paramValueSize = 0;
char *paramValue = nullptr;
@ -197,7 +197,7 @@ TEST_P(KernelTest, GivenKernelBinaryProgramIntelWhenGettingInfoThenKernelBinaryI
delete[] paramValue;
}
TEST_P(KernelTest, givenBinaryWhenItIsQueriedForGpuAddressThenAbsoluteAddressIsReturned) {
TEST_F(KernelTests, givenBinaryWhenItIsQueriedForGpuAddressThenAbsoluteAddressIsReturned) {
cl_kernel_info paramName = CL_KERNEL_BINARY_GPU_ADDRESS_INTEL;
uint64_t paramValue = 0llu;
size_t paramValueSize = sizeof(paramValue);
@ -215,7 +215,7 @@ TEST_P(KernelTest, givenBinaryWhenItIsQueriedForGpuAddressThenAbsoluteAddressIsR
EXPECT_EQ(paramValueSize, paramValueSizeRet);
}
TEST_P(KernelTest, GivenKernelNumArgsWhenGettingInfoThenNumberOfKernelArgsIsReturned) {
TEST_F(KernelTests, GivenKernelNumArgsWhenGettingInfoThenNumberOfKernelArgsIsReturned) {
cl_kernel_info paramName = CL_KERNEL_NUM_ARGS;
size_t paramValueSize = sizeof(cl_uint);
cl_uint paramValue = 0;
@ -233,7 +233,7 @@ TEST_P(KernelTest, GivenKernelNumArgsWhenGettingInfoThenNumberOfKernelArgsIsRetu
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_P(KernelTest, GivenKernelProgramWhenGettingInfoThenProgramIsReturned) {
TEST_F(KernelTests, GivenKernelProgramWhenGettingInfoThenProgramIsReturned) {
cl_kernel_info paramName = CL_KERNEL_PROGRAM;
size_t paramValueSize = sizeof(cl_program);
cl_program paramValue = 0;
@ -252,7 +252,7 @@ TEST_P(KernelTest, GivenKernelProgramWhenGettingInfoThenProgramIsReturned) {
EXPECT_EQ(prog, paramValue);
}
TEST_P(KernelTest, GivenKernelContextWhenGettingInfoThenKernelContextIsReturned) {
TEST_F(KernelTests, GivenKernelContextWhenGettingInfoThenKernelContextIsReturned) {
cl_kernel_info paramName = CL_KERNEL_CONTEXT;
cl_context paramValue = 0;
size_t paramValueSize = sizeof(paramValue);
@ -271,7 +271,7 @@ TEST_P(KernelTest, GivenKernelContextWhenGettingInfoThenKernelContextIsReturned)
EXPECT_EQ(context, paramValue);
}
TEST_P(KernelTest, GivenKernelWorkGroupSizeWhenGettingWorkGroupInfoThenWorkGroupSizeIsReturned) {
TEST_F(KernelTests, GivenKernelWorkGroupSizeWhenGettingWorkGroupInfoThenWorkGroupSizeIsReturned) {
cl_kernel_info paramName = CL_KERNEL_WORK_GROUP_SIZE;
size_t paramValue = 0;
size_t paramValueSize = sizeof(paramValue);
@ -292,7 +292,7 @@ TEST_P(KernelTest, GivenKernelWorkGroupSizeWhenGettingWorkGroupInfoThenWorkGroup
EXPECT_EQ(kernelMaxWorkGroupSize, paramValue);
}
TEST_P(KernelTest, GivenKernelCompileWorkGroupSizeWhenGettingWorkGroupInfoThenCompileWorkGroupSizeIsReturned) {
TEST_F(KernelTests, GivenKernelCompileWorkGroupSizeWhenGettingWorkGroupInfoThenCompileWorkGroupSizeIsReturned) {
cl_kernel_info paramName = CL_KERNEL_COMPILE_WORK_GROUP_SIZE;
size_t paramValue[3];
size_t paramValueSize = sizeof(paramValue);
@ -309,7 +309,7 @@ TEST_P(KernelTest, GivenKernelCompileWorkGroupSizeWhenGettingWorkGroupInfoThenCo
EXPECT_EQ(paramValueSize, paramValueSizeRet);
}
TEST_P(KernelTest, GivenInvalidParamNameWhenGettingWorkGroupInfoThenInvalidValueErrorIsReturned) {
TEST_F(KernelTests, GivenInvalidParamNameWhenGettingWorkGroupInfoThenInvalidValueErrorIsReturned) {
size_t paramValueSizeRet = 0x1234u;
retVal = pKernel->getWorkGroupInfo(
@ -323,12 +323,6 @@ TEST_P(KernelTest, GivenInvalidParamNameWhenGettingWorkGroupInfoThenInvalidValue
EXPECT_EQ(0x1234u, paramValueSizeRet);
}
INSTANTIATE_TEST_CASE_P(KernelTests,
KernelTest,
::testing::Combine(
::testing::ValuesIn(BinaryFileNames),
::testing::ValuesIn(KernelNames)));
class KernelFromBinaryTest : public ProgramSimpleFixture {
public:
void SetUp() override {

20
opencl/test/unit_test/kernel/parent_kernel_tests.cpp
View File

@ -16,8 +16,6 @@
using namespace NEO;
typedef ExecutionModelKernelFixture ParentKernelFromBinaryTest;
class MockKernelWithArgumentAccess : public Kernel {
public:
std::vector<SimpleKernelArgInfo> &getKernelArguments() {
@ -194,16 +192,14 @@ TEST(ParentKernelTest, WhenInitializingParentKernelThenPrivateMemoryForBlocksIsA
EXPECT_NE(nullptr, program->getBlockKernelManager()->getPrivateSurface(program->getBlockKernelManager()->getCount() - 1));
}
TEST_P(ParentKernelFromBinaryTest, GivenParentKernelWhenGettingInstructionHeapSizeForExecutionModelThenSizeIsGreaterThanZero) {
struct ParentKernelFromBinaryTest : public ExecutionModelKernelFixture {
void SetUp() override {
ExecutionModelKernelFixture::SetUp("simple_block_kernel", "simple_block_kernel");
}
};
TEST_F(ParentKernelFromBinaryTest, GivenParentKernelWhenGettingInstructionHeapSizeForExecutionModelThenSizeIsGreaterThanZero) {
EXPECT_TRUE(pKernel->isParentKernel);
EXPECT_LT(0u, pKernel->getInstructionHeapSizeForExecutionModel());
}
static const char *binaryFile = "simple_block_kernel";
static const char *KernelNames[] = {"simple_block_kernel"};
INSTANTIATE_TEST_CASE_P(ParentKernelFromBinaryTest,
ParentKernelFromBinaryTest,
::testing::Combine(
::testing::Values(binaryFile),
::testing::ValuesIn(KernelNames)));

22
opencl/test/unit_test/program/program_from_binary.h
View File

@ -21,17 +21,19 @@ namespace NEO {
// ProgramFromBinaryTest Test Fixture
// Used to test the Program class
////////////////////////////////////////////////////////////////////////////////
class ProgramFromBinaryTest : public ClDeviceFixture,
public ContextFixture,
public ProgramFixture,
public testing::TestWithParam<std::tuple<const char *, const char *>> {
struct ProgramFromBinaryFixture : public ClDeviceFixture,
public ContextFixture,
public ProgramFixture,
public testing::Test {
using ContextFixture::SetUp;
protected:
void SetUp() override {
std::tie(BinaryFileName, kernelName) = GetParam();
ProgramFromBinaryFixture::SetUp("CopyBuffer_simd32", "CopyBuffer");
}
void SetUp(const char *binaryFileName, const char *kernelName) {
this->binaryFileName = binaryFileName;
this->kernelName = kernelName;
ClDeviceFixture::SetUp();
cl_device_id device = pClDevice;
@ -39,9 +41,9 @@ class ProgramFromBinaryTest : public ClDeviceFixture,
ProgramFixture::SetUp();
if (options.size())
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName, options);
CreateProgramFromBinary(pContext, pContext->getDevices(), binaryFileName, options);
else
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
CreateProgramFromBinary(pContext, pContext->getDevices(), binaryFileName);
}
void TearDown() override {
@ -55,7 +57,7 @@ class ProgramFromBinaryTest : public ClDeviceFixture,
options = optionsIn;
}
const char *BinaryFileName = nullptr;
const char *binaryFileName = nullptr;
const char *kernelName = nullptr;
cl_int retVal = CL_SUCCESS;
std::string options;

133
opencl/test/unit_test/program/program_tests.cpp
View File

@ -69,22 +69,6 @@ void ProgramTests::TearDown() {
ClDeviceFixture::TearDown();
}
std::vector<const char *> BinaryFileNames{
"CopyBuffer_simd32",
};
std::vector<const char *> SourceFileNames{
"CopyBuffer_simd16.cl",
};
std::vector<const char *> BinaryForSourceFileNames{
"CopyBuffer_simd16",
};
std::vector<const char *> KernelNames{
"CopyBuffer",
};
class NoCompilerInterfaceRootDeviceEnvironment : public RootDeviceEnvironment {
public:
NoCompilerInterfaceRootDeviceEnvironment(ExecutionEnvironment &executionEnvironment) : RootDeviceEnvironment(executionEnvironment) {
@ -108,7 +92,9 @@ class SucceedingGenBinaryProgram : public MockProgram {
cl_int processGenBinary(const ClDevice &clDevice) override { return CL_SUCCESS; }
};
TEST_P(ProgramFromBinaryTest, WhenBuildingProgramThenSuccessIsReturned) {
using ProgramFromBinaryTest = ProgramFromBinaryFixture;
TEST_F(ProgramFromBinaryTest, WhenBuildingProgramThenSuccessIsReturned) {
retVal = pProgram->build(
pProgram->getDevices(),
nullptr,
@ -117,7 +103,7 @@ TEST_P(ProgramFromBinaryTest, WhenBuildingProgramThenSuccessIsReturned) {
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_P(ProgramFromBinaryTest, WhenGettingProgramContextInfoThenCorrectContextIsReturned) {
TEST_F(ProgramFromBinaryTest, WhenGettingProgramContextInfoThenCorrectContextIsReturned) {
cl_context contextRet = reinterpret_cast<cl_context>(static_cast<uintptr_t>(0xdeaddead));
size_t paramValueSizeRet = 0;
@ -132,7 +118,7 @@ TEST_P(ProgramFromBinaryTest, WhenGettingProgramContextInfoThenCorrectContextIsR
EXPECT_EQ(sizeof(cl_context), paramValueSizeRet);
}
TEST_P(ProgramFromBinaryTest, GivenNonNullParamValueWhenGettingProgramBinaryInfoThenCorrectBinaryIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenNonNullParamValueWhenGettingProgramBinaryInfoThenCorrectBinaryIsReturned) {
size_t paramValueSize = sizeof(unsigned char **);
size_t paramValueSizeRet = 0;
auto testBinary = std::make_unique<char[]>(knownSourceSize);
@ -148,7 +134,7 @@ TEST_P(ProgramFromBinaryTest, GivenNonNullParamValueWhenGettingProgramBinaryInfo
EXPECT_STREQ((const char *)knownSource.get(), (const char *)testBinary.get());
}
TEST_P(ProgramFromBinaryTest, GivenNullParamValueWhenGettingProgramBinaryInfoThenSuccessIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenNullParamValueWhenGettingProgramBinaryInfoThenSuccessIsReturned) {
size_t paramValueSize = sizeof(unsigned char **);
size_t paramValueSizeRet = 0;
@ -161,7 +147,7 @@ TEST_P(ProgramFromBinaryTest, GivenNullParamValueWhenGettingProgramBinaryInfoThe
EXPECT_EQ(paramValueSize, paramValueSizeRet);
}
TEST_P(ProgramFromBinaryTest, GivenNonNullParamValueAndParamValueSizeZeroWhenGettingProgramBinaryInfoThenInvalidValueErrorIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenNonNullParamValueAndParamValueSizeZeroWhenGettingProgramBinaryInfoThenInvalidValueErrorIsReturned) {
size_t paramValueSizeRet = 0;
auto testBinary = std::make_unique<char[]>(knownSourceSize);
@ -173,7 +159,7 @@ TEST_P(ProgramFromBinaryTest, GivenNonNullParamValueAndParamValueSizeZeroWhenGet
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_P(ProgramFromBinaryTest, GivenInvalidParametersWhenGettingProgramInfoThenValueSizeRetIsNotUpdated) {
TEST_F(ProgramFromBinaryTest, GivenInvalidParametersWhenGettingProgramInfoThenValueSizeRetIsNotUpdated) {
size_t paramValueSizeRet = 0x1234;
auto testBinary = std::make_unique<char[]>(knownSourceSize);
@ -186,7 +172,7 @@ TEST_P(ProgramFromBinaryTest, GivenInvalidParametersWhenGettingProgramInfoThenVa
EXPECT_EQ(0x1234u, paramValueSizeRet);
}
TEST_P(ProgramFromBinaryTest, GivenInvalidParamWhenGettingProgramBinaryInfoThenInvalidValueErrorIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenInvalidParamWhenGettingProgramBinaryInfoThenInvalidValueErrorIsReturned) {
size_t paramValueSizeRet = 0;
auto testBinary = std::make_unique<char[]>(knownSourceSize);
@ -198,7 +184,7 @@ TEST_P(ProgramFromBinaryTest, GivenInvalidParamWhenGettingProgramBinaryInfoThenI
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_P(ProgramFromBinaryTest, WhenGettingBinarySizesThenCorrectSizesAreReturned) {
TEST_F(ProgramFromBinaryTest, WhenGettingBinarySizesThenCorrectSizesAreReturned) {
size_t paramValueSize = sizeof(size_t *);
size_t paramValue[1];
size_t paramValueSizeRet = 0;
@ -214,7 +200,7 @@ TEST_P(ProgramFromBinaryTest, WhenGettingBinarySizesThenCorrectSizesAreReturned)
EXPECT_EQ(paramValueSize, paramValueSizeRet);
}
TEST_P(ProgramFromBinaryTest, GivenProgramWithOneKernelWhenGettingNumKernelsThenOneIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenProgramWithOneKernelWhenGettingNumKernelsThenOneIsReturned) {
size_t paramValue = 0;
size_t paramValueSize = sizeof(paramValue);
size_t paramValueSizeRet = 0;
@ -236,12 +222,12 @@ TEST_P(ProgramFromBinaryTest, GivenProgramWithOneKernelWhenGettingNumKernelsThen
EXPECT_EQ(paramValueSize, paramValueSizeRet);
}
TEST_P(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingNumKernelsThenInvalidProgramExecutableErrorIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingNumKernelsThenInvalidProgramExecutableErrorIsReturned) {
size_t paramValue = 0;
size_t paramValueSize = sizeof(paramValue);
size_t paramValueSizeRet = 0;
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
CreateProgramFromBinary(pContext, pContext->getDevices(), binaryFileName);
MockProgram *p = pProgram;
p->setBuildStatus(CL_BUILD_NONE);
@ -253,7 +239,7 @@ TEST_P(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingNumKern
EXPECT_EQ(CL_INVALID_PROGRAM_EXECUTABLE, retVal);
}
TEST_P(ProgramFromBinaryTest, WhenGettingKernelNamesThenCorrectNameIsReturned) {
TEST_F(ProgramFromBinaryTest, WhenGettingKernelNamesThenCorrectNameIsReturned) {
size_t paramValueSize = sizeof(size_t *);
size_t paramValueSizeRet = 0;
@ -289,11 +275,11 @@ TEST_P(ProgramFromBinaryTest, WhenGettingKernelNamesThenCorrectNameIsReturned) {
EXPECT_EQ(expectedKernelsStringSize, paramValueSizeRet);
}
TEST_P(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingKernelNamesThenInvalidProgramExecutableErrorIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingKernelNamesThenInvalidProgramExecutableErrorIsReturned) {
size_t paramValueSize = sizeof(size_t *);
size_t paramValueSizeRet = 0;
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
CreateProgramFromBinary(pContext, pContext->getDevices(), binaryFileName);
MockProgram *p = pProgram;
p->setBuildStatus(CL_BUILD_NONE);
@ -305,7 +291,7 @@ TEST_P(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingKernelN
EXPECT_EQ(CL_INVALID_PROGRAM_EXECUTABLE, retVal);
}
TEST_P(ProgramFromBinaryTest, WhenGettingProgramScopeGlobalCtorsAndDtorsPresentInfoThenCorrectValueIsReturned) {
TEST_F(ProgramFromBinaryTest, WhenGettingProgramScopeGlobalCtorsAndDtorsPresentInfoThenCorrectValueIsReturned) {
cl_uint paramRet = 0;
cl_uint expectedParam = CL_FALSE;
size_t paramSizeRet = 0;
@ -331,7 +317,7 @@ TEST_P(ProgramFromBinaryTest, WhenGettingProgramScopeGlobalCtorsAndDtorsPresentI
EXPECT_EQ(expectedParam, paramRet);
}
TEST_P(ProgramFromBinaryTest, GivenNullDeviceWhenGettingBuildStatusThenBuildNoneIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenNullDeviceWhenGettingBuildStatusThenBuildNoneIsReturned) {
cl_device_id device = pClDevice;
cl_build_status buildStatus = 0;
size_t paramValueSize = sizeof(buildStatus);
@ -349,7 +335,7 @@ TEST_P(ProgramFromBinaryTest, GivenNullDeviceWhenGettingBuildStatusThenBuildNone
EXPECT_EQ(CL_BUILD_NONE, buildStatus);
}
TEST_P(ProgramFromBinaryTest, GivenInvalidParametersWhenGettingBuildInfoThenValueSizeRetIsNotUpdated) {
TEST_F(ProgramFromBinaryTest, GivenInvalidParametersWhenGettingBuildInfoThenValueSizeRetIsNotUpdated) {
cl_device_id device = pClDevice;
cl_build_status buildStatus = 0;
size_t paramValueSize = sizeof(buildStatus);
@ -366,7 +352,7 @@ TEST_P(ProgramFromBinaryTest, GivenInvalidParametersWhenGettingBuildInfoThenValu
EXPECT_EQ(0x1234u, paramValueSizeRet);
}
TEST_P(ProgramFromBinaryTest, GivenDefaultDeviceWhenGettingBuildOptionsThenBuildOptionsAreEmpty) {
TEST_F(ProgramFromBinaryTest, GivenDefaultDeviceWhenGettingBuildOptionsThenBuildOptionsAreEmpty) {
cl_device_id device = pClDevice;
size_t paramValueSizeRet = 0u;
size_t paramValueSize = 0u;
@ -395,7 +381,7 @@ TEST_P(ProgramFromBinaryTest, GivenDefaultDeviceWhenGettingBuildOptionsThenBuild
EXPECT_STREQ("", (char *)paramValue.get());
}
TEST_P(ProgramFromBinaryTest, GivenDefaultDeviceWhenGettingLogThenLogEmpty) {
TEST_F(ProgramFromBinaryTest, GivenDefaultDeviceWhenGettingLogThenLogEmpty) {
cl_device_id device = pClDevice;
size_t paramValueSizeRet = 0u;
size_t paramValueSize = 0u;
@ -424,7 +410,7 @@ TEST_P(ProgramFromBinaryTest, GivenDefaultDeviceWhenGettingLogThenLogEmpty) {
EXPECT_STREQ("", (char *)paramValue.get());
}
TEST_P(ProgramFromBinaryTest, GivenLogEntriesWhenGetBuildLogThenLogIsApended) {
TEST_F(ProgramFromBinaryTest, GivenLogEntriesWhenGetBuildLogThenLogIsApended) {
cl_device_id device = pClDevice;
size_t paramValueSizeRet = 0u;
size_t paramValueSize = 0u;
@ -484,7 +470,7 @@ TEST_P(ProgramFromBinaryTest, GivenLogEntriesWhenGetBuildLogThenLogIsApended) {
ASSERT_NE(nullptr, strstr(paramValueContinued, "several"));
}
TEST_P(ProgramFromBinaryTest, GivenNullParamValueWhenGettingProgramBinaryTypeThenParamValueSizeIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenNullParamValueWhenGettingProgramBinaryTypeThenParamValueSizeIsReturned) {
cl_device_id device = pClDevice;
size_t paramValueSizeRet = 0u;
size_t paramValueSize = 0u;
@ -500,7 +486,7 @@ TEST_P(ProgramFromBinaryTest, GivenNullParamValueWhenGettingProgramBinaryTypeThe
EXPECT_NE(paramValueSizeRet, 0u);
}
TEST_P(ProgramFromBinaryTest, WhenGettingProgramBinaryTypeThenCorrectProgramTypeIsReturned) {
TEST_F(ProgramFromBinaryTest, WhenGettingProgramBinaryTypeThenCorrectProgramTypeIsReturned) {
cl_device_id device = pClDevice;
cl_program_binary_type programType = 0;
char *paramValue = (char *)&programType;
@ -528,7 +514,7 @@ TEST_P(ProgramFromBinaryTest, WhenGettingProgramBinaryTypeThenCorrectProgramType
EXPECT_EQ((cl_program_binary_type)CL_PROGRAM_BINARY_TYPE_EXECUTABLE, programType);
}
TEST_P(ProgramFromBinaryTest, GivenInvalidParamWhenGettingBuildInfoThenInvalidValueErrorIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenInvalidParamWhenGettingBuildInfoThenInvalidValueErrorIsReturned) {
cl_device_id device = pClDevice;
size_t paramValueSizeRet = 0u;
@ -541,7 +527,7 @@ TEST_P(ProgramFromBinaryTest, GivenInvalidParamWhenGettingBuildInfoThenInvalidVa
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_P(ProgramFromBinaryTest, GivenGlobalVariableTotalSizeSetWhenGettingBuildGlobalVariableTotalSizeThenCorrectSizeIsReturned) {
TEST_F(ProgramFromBinaryTest, GivenGlobalVariableTotalSizeSetWhenGettingBuildGlobalVariableTotalSizeThenCorrectSizeIsReturned) {
cl_device_id device = pClDevice;
size_t globalVarSize = 22;
size_t paramValueSize = sizeof(globalVarSize);
@ -561,7 +547,7 @@ TEST_P(ProgramFromBinaryTest, GivenGlobalVariableTotalSizeSetWhenGettingBuildGlo
EXPECT_EQ(globalVarSize, 0u);
// Set GlobalVariableTotalSize as 1024
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
CreateProgramFromBinary(pContext, pContext->getDevices(), binaryFileName);
MockProgram *p = pProgram;
ProgramInfo programInfo;
@ -586,7 +572,7 @@ TEST_P(ProgramFromBinaryTest, GivenGlobalVariableTotalSizeSetWhenGettingBuildGlo
}
}
TEST_P(ProgramFromBinaryTest, givenProgramWhenItIsBeingBuildThenItContainsGraphicsAllocationInKernelInfo) {
TEST_F(ProgramFromBinaryTest, givenProgramWhenItIsBeingBuildThenItContainsGraphicsAllocationInKernelInfo) {
pProgram->build(pProgram->getDevices(), nullptr, true);
auto kernelInfo = pProgram->getKernelInfo(size_t(0), rootDeviceIndex);
@ -602,7 +588,7 @@ TEST_P(ProgramFromBinaryTest, givenProgramWhenItIsBeingBuildThenItContainsGraphi
EXPECT_EQ(GmmHelper::decanonize(graphicsAllocation->getGpuBaseAddress()), pDevice->getMemoryManager()->getInternalHeapBaseAddress(rootDeviceIndex, graphicsAllocation->isAllocatedInLocalMemoryPool()));
}
TEST_P(ProgramFromBinaryTest, whenProgramIsBeingRebuildThenOutdatedGlobalBuffersAreFreed) {
TEST_F(ProgramFromBinaryTest, whenProgramIsBeingRebuildThenOutdatedGlobalBuffersAreFreed) {
pProgram->build(pProgram->getDevices(), nullptr, true);
EXPECT_EQ(nullptr, pProgram->buildInfos[pClDevice->getRootDeviceIndex()].constantSurface);
EXPECT_EQ(nullptr, pProgram->buildInfos[pClDevice->getRootDeviceIndex()].globalSurface);
@ -618,7 +604,7 @@ TEST_P(ProgramFromBinaryTest, whenProgramIsBeingRebuildThenOutdatedGlobalBuffers
EXPECT_EQ(nullptr, pProgram->buildInfos[pClDevice->getRootDeviceIndex()].globalSurface);
}
TEST_P(ProgramFromBinaryTest, givenProgramWhenCleanKernelInfoIsCalledThenKernelAllocationIsFreed) {
TEST_F(ProgramFromBinaryTest, givenProgramWhenCleanKernelInfoIsCalledThenKernelAllocationIsFreed) {
pProgram->build(pProgram->getDevices(), nullptr, true);
EXPECT_EQ(1u, pProgram->getNumKernels());
for (auto i = 0u; i < pProgram->buildInfos.size(); i++) {
@ -627,7 +613,7 @@ TEST_P(ProgramFromBinaryTest, givenProgramWhenCleanKernelInfoIsCalledThenKernelA
EXPECT_EQ(0u, pProgram->getNumKernels());
}
HWTEST_P(ProgramFromBinaryTest, givenProgramWhenCleanCurrentKernelInfoIsCalledButGpuIsNotYetDoneThenKernelAllocationIsPutOnDeferredFreeListAndCsrRegistersCacheFlush) {
HWTEST_F(ProgramFromBinaryTest, givenProgramWhenCleanCurrentKernelInfoIsCalledButGpuIsNotYetDoneThenKernelAllocationIsPutOnDeferredFreeListAndCsrRegistersCacheFlush) {
auto &csr = pDevice->getGpgpuCommandStreamReceiver();
EXPECT_TRUE(csr.getTemporaryAllocations().peekIsEmpty());
pProgram->build(pProgram->getDevices(), nullptr, true);
@ -640,7 +626,7 @@ HWTEST_P(ProgramFromBinaryTest, givenProgramWhenCleanCurrentKernelInfoIsCalledBu
EXPECT_TRUE(this->pDevice->getUltCommandStreamReceiver<FamilyType>().requiresInstructionCacheFlush);
}
HWTEST_P(ProgramFromBinaryTest, givenIsaAllocationUsedByMultipleCsrsWhenItIsDeletedItRegistersCacheFlushInEveryCsrThatUsedIt) {
HWTEST_F(ProgramFromBinaryTest, givenIsaAllocationUsedByMultipleCsrsWhenItIsDeletedItRegistersCacheFlushInEveryCsrThatUsedIt) {
auto &csr0 = this->pDevice->getUltCommandStreamReceiverFromIndex<FamilyType>(0u);
auto &csr1 = this->pDevice->getUltCommandStreamReceiverFromIndex<FamilyType>(1u);
@ -665,13 +651,13 @@ HWTEST_P(ProgramFromBinaryTest, givenIsaAllocationUsedByMultipleCsrsWhenItIsDele
EXPECT_TRUE(csr1.requiresInstructionCacheFlush);
}
TEST_P(ProgramFromSourceTest, GivenSpecificParamatersWhenBuildingProgramThenSuccessOrCorrectErrorCodeIsReturned) {
KernelBinaryHelper kbHelper(BinaryFileName, true);
TEST_F(ProgramFromSourceTest, GivenSpecificParamatersWhenBuildingProgramThenSuccessOrCorrectErrorCodeIsReturned) {
KernelBinaryHelper kbHelper(binaryFileName, true);
auto device = pPlatform->getClDevice(0);
CreateProgramWithSource(
pContext,
SourceFileName);
sourceFileName);
// Order of following microtests is important - do not change.
// Add new microtests at end.
@ -766,8 +752,8 @@ TEST_P(ProgramFromSourceTest, GivenSpecificParamatersWhenBuildingProgramThenSucc
EXPECT_EQ(CL_INVALID_PROGRAM, retVal);
}
TEST_P(ProgramFromSourceTest, CreateWithSource_Build_Options_Duplicate) {
KernelBinaryHelper kbHelper(BinaryFileName, false);
TEST_F(ProgramFromSourceTest, CreateWithSource_Build_Options_Duplicate) {
KernelBinaryHelper kbHelper(binaryFileName, false);
retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -785,7 +771,7 @@ TEST_P(ProgramFromSourceTest, CreateWithSource_Build_Options_Duplicate) {
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_P(ProgramFromSourceTest, WhenBuildingProgramThenFeaturesAreNotAdded) {
TEST_F(ProgramFromSourceTest, WhenBuildingProgramThenFeaturesAreNotAdded) {
auto cip = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = pContext->getDevice(0);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(cip);
@ -800,7 +786,7 @@ TEST_P(ProgramFromSourceTest, WhenBuildingProgramThenFeaturesAreNotAdded) {
EXPECT_THAT(cip->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsWithFeaturesOption)));
}
TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesAreAdded) {
TEST_F(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesAreAdded) {
auto cip = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = pContext->getDevice(0);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(cip);
@ -822,7 +808,7 @@ TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesAreAdd
EXPECT_EQ(1, MockProgram::initInternalOptionsCalled);
}
TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesAreAddedOnlyOnce) {
TEST_F(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesAreAddedOnlyOnce) {
auto cip = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = pContext->getDevice(0);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(cip);
@ -844,7 +830,7 @@ TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesAreAdd
EXPECT_EQ(std::string::npos, pos);
}
TEST_P(ProgramFromSourceTest, WhenCompilingProgramThenFeaturesAreNotAdded) {
TEST_F(ProgramFromSourceTest, WhenCompilingProgramThenFeaturesAreNotAdded) {
auto pCompilerInterface = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = static_cast<ClDevice *>(devices[0]);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(pCompilerInterface);
@ -861,7 +847,7 @@ TEST_P(ProgramFromSourceTest, WhenCompilingProgramThenFeaturesAreNotAdded) {
EXPECT_EQ(1, MockProgram::initInternalOptionsCalled);
}
TEST_P(ProgramFromSourceTest, WhenCompilingProgramWithOpenClC30ThenFeaturesAreAdded) {
TEST_F(ProgramFromSourceTest, WhenCompilingProgramWithOpenClC30ThenFeaturesAreAdded) {
auto pCompilerInterface = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = pContext->getDevice(0);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(pCompilerInterface);
@ -908,14 +894,14 @@ class Callback {
std::map<const void *, uint32_t> Callback::watchList;
TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramThenKernelHashesAreDifferent) {
KernelBinaryHelper kbHelper(BinaryFileName, true);
TEST_F(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramThenKernelHashesAreDifferent) {
KernelBinaryHelper kbHelper(binaryFileName, true);
auto rootDeviceIndex = pContext->getDevice(0)->getRootDeviceIndex();
CreateProgramWithSource(
pContext,
SourceFileName);
sourceFileName);
Callback callback;
@ -967,17 +953,17 @@ TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramT
Callback::unwatch(kernel4);
}
TEST_P(ProgramFromSourceTest, GivenEmptyProgramWhenCreatingProgramThenInvalidValueErrorIsReturned) {
TEST_F(ProgramFromSourceTest, GivenEmptyProgramWhenCreatingProgramThenInvalidValueErrorIsReturned) {
auto p = Program::create(pContext, 0, nullptr, nullptr, retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(nullptr, p);
delete p;
}
TEST_P(ProgramFromSourceTest, GivenSpecificParamatersWhenCompilingProgramThenSuccessOrCorrectErrorCodeIsReturned) {
TEST_F(ProgramFromSourceTest, GivenSpecificParamatersWhenCompilingProgramThenSuccessOrCorrectErrorCodeIsReturned) {
CreateProgramWithSource(
pContext,
SourceFileName);
sourceFileName);
cl_program inputHeaders;
const char *headerIncludeNames = "";
@ -1058,7 +1044,7 @@ TEST_P(ProgramFromSourceTest, GivenSpecificParamatersWhenCompilingProgramThenSuc
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_P(ProgramFromSourceTest, GivenFlagsWhenCompilingProgramThenBuildOptionsHaveBeenApplied) {
TEST_F(ProgramFromSourceTest, GivenFlagsWhenCompilingProgramThenBuildOptionsHaveBeenApplied) {
auto cip = new MockCompilerInterfaceCaptureBuildOptions();
auto pDevice = pContext->getDevice(0);
pDevice->getExecutionEnvironment()->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->compilerInterface.reset(cip);
@ -1123,7 +1109,7 @@ TEST_F(ProgramTests, GivenFlagsWhenLinkingProgramThenBuildOptionsHaveBeenApplied
EXPECT_TRUE(CompilerOptions::contains(cip->buildInternalOptions, CompilerOptions::greaterThan4gbBuffersRequired)) << cip->buildInternalOptions;
}
TEST_P(ProgramFromSourceTest, GivenAdvancedOptionsWhenCreatingProgramThenSuccessIsReturned) {
TEST_F(ProgramFromSourceTest, GivenAdvancedOptionsWhenCreatingProgramThenSuccessIsReturned) {
std::string testFile;
size_t sourceSize = 0;
@ -1175,10 +1161,10 @@ TEST_P(ProgramFromSourceTest, GivenAdvancedOptionsWhenCreatingProgramThenSuccess
delete[] ptr;
}
TEST_P(ProgramFromSourceTest, GivenSpecificParamatersWhenLinkingProgramThenSuccessOrCorrectErrorCodeIsReturned) {
TEST_F(ProgramFromSourceTest, GivenSpecificParamatersWhenLinkingProgramThenSuccessOrCorrectErrorCodeIsReturned) {
CreateProgramWithSource(
pContext,
SourceFileName);
sourceFileName);
cl_program program = pProgram;
cl_program nullprogram = nullptr;
@ -1243,7 +1229,7 @@ TEST_P(ProgramFromSourceTest, GivenSpecificParamatersWhenLinkingProgramThenSucce
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_P(ProgramFromSourceTest, GivenInvalidOptionsWhenCreatingLibraryThenCorrectErrorIsReturned) {
TEST_F(ProgramFromSourceTest, GivenInvalidOptionsWhenCreatingLibraryThenCorrectErrorIsReturned) {
cl_program program = pProgram;
// Order of following microtests is important - do not change.
@ -1552,19 +1538,6 @@ TEST(ProgramFromBinaryTests, givenEmptyProgramThenErrorIsReturned) {
EXPECT_EQ(CL_INVALID_BINARY, retVal);
}
INSTANTIATE_TEST_CASE_P(ProgramFromBinaryTests,
ProgramFromBinaryTest,
::testing::Combine(
::testing::ValuesIn(BinaryFileNames),
::testing::ValuesIn(KernelNames)));
INSTANTIATE_TEST_CASE_P(ProgramFromSourceTests,
ProgramFromSourceTest,
::testing::Combine(
::testing::ValuesIn(SourceFileNames),
::testing::ValuesIn(BinaryForSourceFileNames),
::testing::ValuesIn(KernelNames)));
using ProgramWithDebugSymbolsTests = Test<ProgramSimpleFixture>;
TEST_F(ProgramWithDebugSymbolsTests, GivenProgramCreatedWithDashGOptionWhenGettingProgramBinariesThenDebugDataIsIncluded) {

5
opencl/test/unit_test/program/program_tests.h
View File

@ -13,11 +13,6 @@
#include <vector>
extern std::vector<const char *> BinaryFileNames;
extern std::vector<const char *> SourceFileNames;
extern std::vector<const char *> BinaryForSourceFileNames;
extern std::vector<const char *> KernelNames;
class ProgramTests : public NEO::ClDeviceFixture,
public ::testing::Test,
public NEO::ContextFixture {

12
opencl/test/unit_test/program/program_with_source.h
View File

@ -31,8 +31,10 @@ class ProgramFromSourceTest : public ContextFixture,
protected:
void SetUp() override {
std::tie(SourceFileName, BinaryFileName, kernelName) = GetParam();
kbHelper = new KernelBinaryHelper(BinaryFileName);
sourceFileName = "CopyBuffer_simd16.cl";
binaryFileName = "CopyBuffer_simd16";
kernelName = "CopyBuffer";
kbHelper = new KernelBinaryHelper(binaryFileName);
PlatformFixture::SetUp();
cl_device_id device = pPlatform->getClDevice(0);
@ -42,7 +44,7 @@ class ProgramFromSourceTest : public ContextFixture,
CreateProgramWithSource(
pContext,
SourceFileName);
sourceFileName);
}
void TearDown() override {
@ -54,8 +56,8 @@ class ProgramFromSourceTest : public ContextFixture,
}
KernelBinaryHelper *kbHelper = nullptr;
const char *SourceFileName = nullptr;
const char *BinaryFileName = nullptr;
const char *sourceFileName = nullptr;
const char *binaryFileName = nullptr;
const char *kernelName = nullptr;
cl_int retVal = CL_SUCCESS;
uint32_t rootDeviceIndex = std::numeric_limits<uint32_t>::max();