ULT renaming: Gen-specific Device Capabilities tests

AdamCetnerowski · Compute-Runtime-Automation · commit 2eea76e0860e · 2020-10-26T18:04:54.000+01:00
Related-To: NEO-2236

Change-Id: Ie499506585f929e73547e8f3f39aea2a16a77c48
Signed-off-by: Adam Cetnerowski &lt;adam.cetnerowski@intel.com&gt;
diff --git a/opencl/test/unit_test/gen11/lkf/test_device_caps_lkf.cpp b/opencl/test/unit_test/gen11/lkf/test_device_caps_lkf.cpp
@@ -16,7 +16,7 @@ LKFTEST_F(LkfTest, givenLkfWhenSlmSizeIsRequiredThenReturnCorrectValue) {
     EXPECT_EQ(64u, pDevice->getHardwareInfo().capabilityTable.slmSize);
 }
 
-LKFTEST_F(LkfTest, givenLKFWhenCheckedSvmSupportThenNoSvmIsReported) {
+LKFTEST_F(LkfTest, givenLkfWhenCheckedSvmSupportThenNoSvmIsReported) {
     const auto &caps = pClDevice->getDeviceInfo();
     EXPECT_EQ(caps.svmCapabilities, 0u);
 }
@@ -34,7 +34,7 @@ LKFTEST_F(LkfTest, givenLkfWhenExtensionStringIsCheckedThenFP64IsNotReported) {
     EXPECT_EQ(0u, caps.doubleFpConfig);
 }
 
-LKFTEST_F(LkfTest, isSimulationCap) {
+LKFTEST_F(LkfTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {
     unsigned short lkfSimulationIds[2] = {
         ILKF_1x8x8_DESK_DEVICE_F0_ID,
         0, // default, non-simulation
diff --git a/opencl/test/unit_test/gen11/test_device_caps_gen11.cpp b/opencl/test/unit_test/gen11/test_device_caps_gen11.cpp
@@ -14,16 +14,16 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> Gen11DeviceCaps;
 
-GEN11TEST_F(Gen11DeviceCaps, defaultPreemptionMode) {
+GEN11TEST_F(Gen11DeviceCaps, GivenDefaultWhenCheckingPreemptionModeThenMidThreadIsReturned) {
     EXPECT_TRUE(PreemptionMode::MidThread == pDevice->getHardwareInfo().capabilityTable.defaultPreemptionMode);
 }
 
-GEN11TEST_F(Gen11DeviceCaps, profilingTimerResolution) {
+GEN11TEST_F(Gen11DeviceCaps, WhenCheckingProfilingTimerResolutionThenCorrectResolutionIsReturned) {
     const auto &caps = pDevice->getDeviceInfo();
     EXPECT_EQ(83u, caps.outProfilingTimerResolution);
 }
 
-GEN11TEST_F(Gen11DeviceCaps, kmdNotifyMechanism) {
+GEN11TEST_F(Gen11DeviceCaps, GivenWhenGettingKmdNotifyPropertiesThenItIsDisabled) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableKmdNotify);
     EXPECT_EQ(0, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableQuickKmdSleep);
@@ -32,7 +32,7 @@ GEN11TEST_F(Gen11DeviceCaps, kmdNotifyMechanism) {
     EXPECT_EQ(0, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayQuickKmdSleepForSporadicWaitsMicroseconds);
 }
 
-GEN11TEST_F(Gen11DeviceCaps, compression) {
+GEN11TEST_F(Gen11DeviceCaps, WhenCheckingCompressionThenItIsDisabled) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftrRenderCompressedBuffers);
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftrRenderCompressedImages);
 }
diff --git a/opencl/test/unit_test/gen12lp/adls/test_device_caps_adls.cpp b/opencl/test/unit_test/gen12lp/adls/test_device_caps_adls.cpp
@@ -13,7 +13,7 @@ using namespace NEO;
 
 using AdlsUsDeviceIdTest = Test<ClDeviceFixture>;
 
-ADLSTEST_F(AdlsUsDeviceIdTest, isSimulationCap) {
+ADLSTEST_F(AdlsUsDeviceIdTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {
     unsigned short adlsSimulationIds[2] = {
         DEVICE_ID_4680,
         0, // default, non-simulation
@@ -32,7 +32,7 @@ ADLSTEST_F(AdlsUsDeviceIdTest, isSimulationCap) {
     }
 }
 
-ADLSTEST_F(AdlsUsDeviceIdTest, givenADLSWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {
+ADLSTEST_F(AdlsUsDeviceIdTest, givenAdlsWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {
     EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
 }
 
diff --git a/opencl/test/unit_test/gen8/bdw/test_device_caps_bdw.cpp b/opencl/test/unit_test/gen8/bdw/test_device_caps_bdw.cpp
@@ -14,20 +14,20 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> BdwDeviceCaps;
 
-BDWTEST_F(BdwDeviceCaps, skuSpecificCaps) {
+BDWTEST_F(BdwDeviceCaps, WhenCheckingExtensionStringThenFp64IsSupported) {
     const auto &caps = pClDevice->getDeviceInfo();
     std::string extensionString = caps.deviceExtensions;
 
     EXPECT_NE(std::string::npos, extensionString.find(std::string("cl_khr_fp64")));
     EXPECT_NE(0u, caps.doubleFpConfig);
 }
 
-BDWTEST_F(BdwDeviceCaps, allSkusSupportCorrectlyRoundedDivideSqrt) {
+BDWTEST_F(BdwDeviceCaps, WhenGettingDeviceInfoThenCorrectlyRoundedDivideSqrtIsEnabled) {
     const auto &caps = pClDevice->getDeviceInfo();
     EXPECT_NE(0u, caps.singleFpConfig & CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT);
 }
 
-BDWTEST_F(BdwDeviceCaps, defaultPreemptionMode) {
+BDWTEST_F(BdwDeviceCaps, GivenDefaultWhenCheckingPreemptionModeThenDisabledIsReported) {
     EXPECT_TRUE(PreemptionMode::Disabled == pDevice->getHardwareInfo().capabilityTable.defaultPreemptionMode);
 }
 
@@ -55,7 +55,7 @@ BDWTEST_F(BdwDeviceCaps, givenHwInfoWhenRequestedMaxFrontEndThreadsThenReturnVal
 
 typedef Test<ClDeviceFixture> BdwUsDeviceIdTest;
 
-BDWTEST_F(BdwUsDeviceIdTest, isSimulationCap) {
+BDWTEST_F(BdwUsDeviceIdTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {
     unsigned short bdwSimulationIds[6] = {
         IBDW_GT0_DESK_DEVICE_F0_ID,
         IBDW_GT1_DESK_DEVICE_F0_ID,
@@ -78,6 +78,6 @@ BDWTEST_F(BdwUsDeviceIdTest, isSimulationCap) {
     }
 }
 
-BDWTEST_F(BdwUsDeviceIdTest, GivenBDWWhenCheckftr64KBpagesThenFalse) {
+BDWTEST_F(BdwUsDeviceIdTest, GivenBdwWhenCheckftr64KBpagesThenFalse) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftr64KBpages);
 }
diff --git a/opencl/test/unit_test/gen8/bdw/windows/test_device_caps_bdw_windows.cpp b/opencl/test/unit_test/gen8/bdw/windows/test_device_caps_bdw_windows.cpp
@@ -14,7 +14,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> BdwDeviceCaps;
 
-BDWTEST_F(BdwDeviceCaps, kmdNotifyMechanism) {
+BDWTEST_F(BdwDeviceCaps, WhenCheckingKmdNotifyPropertiesThenKmdNotifyIsEnabledCorrectly) {
     EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableKmdNotify);
     EXPECT_EQ(50000, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
     EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableQuickKmdSleep);
diff --git a/opencl/test/unit_test/gen9/bxt/test_device_caps_bxt.cpp b/opencl/test/unit_test/gen9/bxt/test_device_caps_bxt.cpp
@@ -12,7 +12,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> BxtDeviceCaps;
 
-BXTTEST_F(BxtDeviceCaps, BxtProfilingTimerResolution) {
+BXTTEST_F(BxtDeviceCaps, WhenCheckingProfilingTimerResolutionThenCorrectResolutionIsReturned) {
     const auto &caps = pDevice->getDeviceInfo();
     EXPECT_EQ(52u, caps.outProfilingTimerResolution);
 }
@@ -29,22 +29,22 @@ BXTTEST_F(BxtDeviceCaps, givenBxtDeviceWhenAskedFor32BitSupportThenCorrectValues
     }
 }
 
-BXTTEST_F(BxtDeviceCaps, BxtSvmCapabilities) {
+BXTTEST_F(BxtDeviceCaps, WhenCheckingCapabilitiesThenSvmIsNotSupported) {
     const auto &caps = pClDevice->getDeviceInfo();
     EXPECT_EQ(0u, caps.svmCapabilities);
 }
 
-BXTTEST_F(BxtDeviceCaps, GivenBXTWhenCheckftr64KBpagesThenFalse) {
+BXTTEST_F(BxtDeviceCaps, WhenCheckftr64KBpagesThenFalse) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftr64KBpages);
 }
 
-BXTTEST_F(BxtDeviceCaps, givenBXTWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {
+BXTTEST_F(BxtDeviceCaps, WhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
 }
 
 typedef Test<ClDeviceFixture> BxtUsDeviceIdTest;
 
-BXTTEST_F(BxtUsDeviceIdTest, isSimulationCap) {
+BXTTEST_F(BxtUsDeviceIdTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {
     unsigned short bxtSimulationIds[3] = {
         IBXT_A_DEVICE_F0_ID,
         IBXT_C_DEVICE_F0_ID,
diff --git a/opencl/test/unit_test/gen9/bxt/windows/test_device_caps_bxt_windows.cpp b/opencl/test/unit_test/gen9/bxt/windows/test_device_caps_bxt_windows.cpp
@@ -12,7 +12,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> BxtDeviceCapsWindows;
 
-BXTTEST_F(BxtDeviceCapsWindows, givenHwInfoWhenAskedForKmdNotifyMechanismThenReturnCorrectValues) {
+BXTTEST_F(BxtDeviceCapsWindows, GivenWhenGettingKmdNotifyPropertiesThenItIsDisabled) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableKmdNotify);
     EXPECT_EQ(0, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableQuickKmdSleep);
diff --git a/opencl/test/unit_test/gen9/cfl/windows/test_device_caps_cfl_windows.cpp b/opencl/test/unit_test/gen9/cfl/windows/test_device_caps_cfl_windows.cpp
@@ -12,7 +12,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> CflDeviceCapsWindows;
 
-CFLTEST_F(CflDeviceCapsWindows, givenHwInfoWhenAskedForKmdNotifyMechanismThenReturnCorrectValues) {
+CFLTEST_F(CflDeviceCapsWindows, GivenWhenGettingKmdNotifyPropertiesThenItIsDisabled) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableKmdNotify);
     EXPECT_EQ(0, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableQuickKmdSleep);
diff --git a/opencl/test/unit_test/gen9/glk/test_device_caps_glk.cpp b/opencl/test/unit_test/gen9/glk/test_device_caps_glk.cpp
@@ -12,7 +12,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> Gen9DeviceCaps;
 
-GLKTEST_F(Gen9DeviceCaps, GlkProfilingTimerResolution) {
+GLKTEST_F(Gen9DeviceCaps, WhenCheckingProfilingTimerResolutionThenCorrectResolutionIsReturned) {
     const auto &caps = pDevice->getDeviceInfo();
     EXPECT_EQ(52u, caps.outProfilingTimerResolution);
 }
@@ -35,7 +35,7 @@ GLKTEST_F(Gen9DeviceCaps, GlkIs32BitOsAllocatorAvailable) {
 
 typedef Test<ClDeviceFixture> GlkUsDeviceIdTest;
 
-GLKTEST_F(GlkUsDeviceIdTest, isSimulationCap) {
+GLKTEST_F(GlkUsDeviceIdTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {
     unsigned short glkSimulationIds[3] = {
         IGLK_GT2_ULT_18EU_DEVICE_F0_ID,
         IGLK_GT2_ULT_12EU_DEVICE_F0_ID,
diff --git a/opencl/test/unit_test/gen9/glk/windows/test_device_caps_glk_windows.cpp b/opencl/test/unit_test/gen9/glk/windows/test_device_caps_glk_windows.cpp
@@ -12,7 +12,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> GlkDeviceCapsWindows;
 
-GLKTEST_F(GlkDeviceCapsWindows, givenHwInfoWhenAskedForKmdNotifyMechanismThenReturnCorrectValues) {
+GLKTEST_F(GlkDeviceCapsWindows, WhenCheckingKmdNotifyPropertiesThenKmdNotifyIsEnabledCorrectly) {
     EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableKmdNotify);
     EXPECT_EQ(30000, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableQuickKmdSleep);
diff --git a/opencl/test/unit_test/gen9/kbl/windows/test_device_caps_kbl_windows.cpp b/opencl/test/unit_test/gen9/kbl/windows/test_device_caps_kbl_windows.cpp
@@ -12,7 +12,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> KblDeviceCapsWindows;
 
-KBLTEST_F(KblDeviceCapsWindows, givenHwInfoWhenAskedForKmdNotifyMechanismThenReturnCorrectValues) {
+KBLTEST_F(KblDeviceCapsWindows, GivenWhenGettingKmdNotifyPropertiesThenItIsDisabled) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableKmdNotify);
     EXPECT_EQ(0, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableQuickKmdSleep);
diff --git a/opencl/test/unit_test/gen9/skl/test_device_caps_skl.cpp b/opencl/test/unit_test/gen9/skl/test_device_caps_skl.cpp
@@ -12,7 +12,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> SklDeviceCaps;
 
-SKLTEST_F(SklDeviceCaps, SklProfilingTimerResolution) {
+SKLTEST_F(SklDeviceCaps, WhenCheckingProfilingTimerResolutionThenCorrectResolutionIsReturned) {
     const auto &caps = pDevice->getDeviceInfo();
     EXPECT_EQ(83u, caps.outProfilingTimerResolution);
 }
@@ -24,7 +24,7 @@ SKLTEST_F(SklDeviceCaps, givenSklDeviceWhenAskedFor32BitSupportThenFalseIsReturn
     EXPECT_FALSE(sharedCaps.force32BitAddressess);
 }
 
-SKLTEST_F(SklDeviceCaps, SklSvmCapabilities) {
+SKLTEST_F(SklDeviceCaps, WhenCheckingCapabilitiesThenSvmIsEnabled) {
     const auto &caps = pClDevice->getDeviceInfo();
     cl_device_svm_capabilities expectedCaps = (CL_DEVICE_SVM_COARSE_GRAIN_BUFFER |
                                                CL_DEVICE_SVM_FINE_GRAIN_BUFFER |
@@ -34,7 +34,7 @@ SKLTEST_F(SklDeviceCaps, SklSvmCapabilities) {
 
 typedef Test<ClDeviceFixture> SklUsDeviceIdTest;
 
-SKLTEST_F(SklUsDeviceIdTest, isSimulationCap) {
+SKLTEST_F(SklUsDeviceIdTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {
     unsigned short sklSimulationIds[6] = {
         ISKL_GT0_DESK_DEVICE_F0_ID,
         ISKL_GT1_DESK_DEVICE_F0_ID,
diff --git a/opencl/test/unit_test/gen9/skl/windows/test_device_caps_skl_windows.cpp b/opencl/test/unit_test/gen9/skl/windows/test_device_caps_skl_windows.cpp
@@ -12,7 +12,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> SklDeviceCapsWindows;
 
-SKLTEST_F(SklDeviceCapsWindows, givenHwInfoWhenAskedForKmdNotifyMechanismThenReturnCorrectValues) {
+SKLTEST_F(SklDeviceCapsWindows, GivenWhenGettingKmdNotifyPropertiesThenItIsDisabled) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableKmdNotify);
     EXPECT_EQ(0, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableQuickKmdSleep);
diff --git a/opencl/test/unit_test/gen9/test_device_caps_gen9.cpp b/opencl/test/unit_test/gen9/test_device_caps_gen9.cpp
@@ -14,7 +14,7 @@ using namespace NEO;
 
 typedef Test<ClDeviceFixture> Gen9DeviceCaps;
 
-GEN9TEST_F(Gen9DeviceCaps, skuSpecificCaps) {
+GEN9TEST_F(Gen9DeviceCaps, WhenCheckingExtensionStringThenFp64CorrectlyReported) {
     const auto &caps = pClDevice->getDeviceInfo();
     std::string extensionString = caps.deviceExtensions;
     if (pDevice->getHardwareInfo().capabilityTable.ftrSupportsFP64) {
@@ -45,16 +45,16 @@ GEN9TEST_F(Gen9DeviceCaps, givenGen9WhenCheckingCapsThenDeviceDoesProperlyReport
     }
 }
 
-GEN9TEST_F(Gen9DeviceCaps, allSkusSupportCorrectlyRoundedDivideSqrt) {
+GEN9TEST_F(Gen9DeviceCaps, WhenGettingDeviceInfoThenCorrectlyRoundedDivideSqrtIsEnabled) {
     const auto &caps = pClDevice->getDeviceInfo();
     EXPECT_NE(0u, caps.singleFpConfig & CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT);
 }
 
-GEN9TEST_F(Gen9DeviceCaps, defaultPreemptionMode) {
+GEN9TEST_F(Gen9DeviceCaps, GivenDefaultWhenCheckingPreemptionModeThenMidThreadIsSupported) {
     EXPECT_EQ(PreemptionMode::MidThread, pDevice->getHardwareInfo().capabilityTable.defaultPreemptionMode);
 }
 
-GEN9TEST_F(Gen9DeviceCaps, compression) {
+GEN9TEST_F(Gen9DeviceCaps, WhenCheckingCompressionThenItIsDisabled) {
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftrRenderCompressedBuffers);
     EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftrRenderCompressedImages);
 }

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ LKFTEST_F(LkfTest, givenLkfWhenSlmSizeIsRequiredThenReturnCorrectValue) {`
`16`	`16`	`EXPECT_EQ(64u, pDevice->getHardwareInfo().capabilityTable.slmSize);`
`17`	`17`	`}`
`18`	`18`
`19`		`-LKFTEST_F(LkfTest, givenLKFWhenCheckedSvmSupportThenNoSvmIsReported) {`
	`19`	`+LKFTEST_F(LkfTest, givenLkfWhenCheckedSvmSupportThenNoSvmIsReported) {`
`20`	`20`	`const auto &caps = pClDevice->getDeviceInfo();`
`21`	`21`	`EXPECT_EQ(caps.svmCapabilities, 0u);`
`22`	`22`	`}`
`@@ -34,7 +34,7 @@ LKFTEST_F(LkfTest, givenLkfWhenExtensionStringIsCheckedThenFP64IsNotReported) {`
`34`	`34`	`EXPECT_EQ(0u, caps.doubleFpConfig);`
`35`	`35`	`}`
`36`	`36`
`37`		`-LKFTEST_F(LkfTest, isSimulationCap) {`
	`37`	`+LKFTEST_F(LkfTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {`
`38`	`38`	`unsigned short lkfSimulationIds[2] = {`
`39`	`39`	`ILKF_1x8x8_DESK_DEVICE_F0_ID,`
`40`	`40`	`0, // default, non-simulation`
Original file line number	Diff line number	Diff line change
`@@ -14,16 +14,16 @@ using namespace NEO;`
`14`	`14`
`15`	`15`	`typedef Test<ClDeviceFixture> Gen11DeviceCaps;`
`16`	`16`
`17`		`-GEN11TEST_F(Gen11DeviceCaps, defaultPreemptionMode) {`
	`17`	`+GEN11TEST_F(Gen11DeviceCaps, GivenDefaultWhenCheckingPreemptionModeThenMidThreadIsReturned) {`
`18`	`18`	`EXPECT_TRUE(PreemptionMode::MidThread == pDevice->getHardwareInfo().capabilityTable.defaultPreemptionMode);`
`19`	`19`	`}`
`20`	`20`
`21`		`-GEN11TEST_F(Gen11DeviceCaps, profilingTimerResolution) {`
	`21`	`+GEN11TEST_F(Gen11DeviceCaps, WhenCheckingProfilingTimerResolutionThenCorrectResolutionIsReturned) {`
`22`	`22`	`const auto &caps = pDevice->getDeviceInfo();`
`23`	`23`	`EXPECT_EQ(83u, caps.outProfilingTimerResolution);`
`24`	`24`	`}`
`25`	`25`
`26`		`-GEN11TEST_F(Gen11DeviceCaps, kmdNotifyMechanism) {`
	`26`	`+GEN11TEST_F(Gen11DeviceCaps, GivenWhenGettingKmdNotifyPropertiesThenItIsDisabled) {`
`27`	`27`	`EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableKmdNotify);`
`28`	`28`	`EXPECT_EQ(0, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);`
`29`	`29`	`EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.enableQuickKmdSleep);`
`@@ -32,7 +32,7 @@ GEN11TEST_F(Gen11DeviceCaps, kmdNotifyMechanism) {`
`32`	`32`	`EXPECT_EQ(0, pDevice->getHardwareInfo().capabilityTable.kmdNotifyProperties.delayQuickKmdSleepForSporadicWaitsMicroseconds);`
`33`	`33`	`}`
`34`	`34`
`35`		`-GEN11TEST_F(Gen11DeviceCaps, compression) {`
	`35`	`+GEN11TEST_F(Gen11DeviceCaps, WhenCheckingCompressionThenItIsDisabled) {`
`36`	`36`	`EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftrRenderCompressedBuffers);`
`37`	`37`	`EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftrRenderCompressedImages);`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ using namespace NEO;`
`13`	`13`
`14`	`14`	`using AdlsUsDeviceIdTest = Test<ClDeviceFixture>;`
`15`	`15`
`16`		`-ADLSTEST_F(AdlsUsDeviceIdTest, isSimulationCap) {`
	`16`	`+ADLSTEST_F(AdlsUsDeviceIdTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {`
`17`	`17`	`unsigned short adlsSimulationIds[2] = {`
`18`	`18`	`DEVICE_ID_4680,`
`19`	`19`	`0, // default, non-simulation`
`@@ -32,7 +32,7 @@ ADLSTEST_F(AdlsUsDeviceIdTest, isSimulationCap) {`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
`35`		`-ADLSTEST_F(AdlsUsDeviceIdTest, givenADLSWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {`
	`35`	`+ADLSTEST_F(AdlsUsDeviceIdTest, givenAdlsWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {`
`36`	`36`	`EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);`
`37`	`37`	`}`
`38`	`38`
Original file line number	Diff line number	Diff line change
`@@ -14,20 +14,20 @@ using namespace NEO;`
`14`	`14`
`15`	`15`	`typedef Test<ClDeviceFixture> BdwDeviceCaps;`
`16`	`16`
`17`		`-BDWTEST_F(BdwDeviceCaps, skuSpecificCaps) {`
	`17`	`+BDWTEST_F(BdwDeviceCaps, WhenCheckingExtensionStringThenFp64IsSupported) {`
`18`	`18`	`const auto &caps = pClDevice->getDeviceInfo();`
`19`	`19`	`std::string extensionString = caps.deviceExtensions;`
`20`	`20`
`21`	`21`	`EXPECT_NE(std::string::npos, extensionString.find(std::string("cl_khr_fp64")));`
`22`	`22`	`EXPECT_NE(0u, caps.doubleFpConfig);`
`23`	`23`	`}`
`24`	`24`
`25`		`-BDWTEST_F(BdwDeviceCaps, allSkusSupportCorrectlyRoundedDivideSqrt) {`
	`25`	`+BDWTEST_F(BdwDeviceCaps, WhenGettingDeviceInfoThenCorrectlyRoundedDivideSqrtIsEnabled) {`
`26`	`26`	`const auto &caps = pClDevice->getDeviceInfo();`
`27`	`27`	`EXPECT_NE(0u, caps.singleFpConfig & CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT);`
`28`	`28`	`}`
`29`	`29`
`30`		`-BDWTEST_F(BdwDeviceCaps, defaultPreemptionMode) {`
	`30`	`+BDWTEST_F(BdwDeviceCaps, GivenDefaultWhenCheckingPreemptionModeThenDisabledIsReported) {`
`31`	`31`	`EXPECT_TRUE(PreemptionMode::Disabled == pDevice->getHardwareInfo().capabilityTable.defaultPreemptionMode);`
`32`	`32`	`}`
`33`	`33`
`@@ -55,7 +55,7 @@ BDWTEST_F(BdwDeviceCaps, givenHwInfoWhenRequestedMaxFrontEndThreadsThenReturnVal`
`55`	`55`
`56`	`56`	`typedef Test<ClDeviceFixture> BdwUsDeviceIdTest;`
`57`	`57`
`58`		`-BDWTEST_F(BdwUsDeviceIdTest, isSimulationCap) {`
	`58`	`+BDWTEST_F(BdwUsDeviceIdTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {`
`59`	`59`	`unsigned short bdwSimulationIds[6] = {`
`60`	`60`	`IBDW_GT0_DESK_DEVICE_F0_ID,`
`61`	`61`	`IBDW_GT1_DESK_DEVICE_F0_ID,`
`@@ -78,6 +78,6 @@ BDWTEST_F(BdwUsDeviceIdTest, isSimulationCap) {`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`
`81`		`-BDWTEST_F(BdwUsDeviceIdTest, GivenBDWWhenCheckftr64KBpagesThenFalse) {`
	`81`	`+BDWTEST_F(BdwUsDeviceIdTest, GivenBdwWhenCheckftr64KBpagesThenFalse) {`
`82`	`82`	`EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftr64KBpages);`
`83`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ using namespace NEO;`
`12`	`12`
`13`	`13`	`typedef Test<ClDeviceFixture> BxtDeviceCaps;`
`14`	`14`
`15`		`-BXTTEST_F(BxtDeviceCaps, BxtProfilingTimerResolution) {`
	`15`	`+BXTTEST_F(BxtDeviceCaps, WhenCheckingProfilingTimerResolutionThenCorrectResolutionIsReturned) {`
`16`	`16`	`const auto &caps = pDevice->getDeviceInfo();`
`17`	`17`	`EXPECT_EQ(52u, caps.outProfilingTimerResolution);`
`18`	`18`	`}`
`@@ -29,22 +29,22 @@ BXTTEST_F(BxtDeviceCaps, givenBxtDeviceWhenAskedFor32BitSupportThenCorrectValues`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`-BXTTEST_F(BxtDeviceCaps, BxtSvmCapabilities) {`
	`32`	`+BXTTEST_F(BxtDeviceCaps, WhenCheckingCapabilitiesThenSvmIsNotSupported) {`
`33`	`33`	`const auto &caps = pClDevice->getDeviceInfo();`
`34`	`34`	`EXPECT_EQ(0u, caps.svmCapabilities);`
`35`	`35`	`}`
`36`	`36`
`37`		`-BXTTEST_F(BxtDeviceCaps, GivenBXTWhenCheckftr64KBpagesThenFalse) {`
	`37`	`+BXTTEST_F(BxtDeviceCaps, WhenCheckftr64KBpagesThenFalse) {`
`38`	`38`	`EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftr64KBpages);`
`39`	`39`	`}`
`40`	`40`
`41`		`-BXTTEST_F(BxtDeviceCaps, givenBXTWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {`
	`41`	`+BXTTEST_F(BxtDeviceCaps, WhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {`
`42`	`42`	`EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`typedef Test<ClDeviceFixture> BxtUsDeviceIdTest;`
`46`	`46`
`47`		`-BXTTEST_F(BxtUsDeviceIdTest, isSimulationCap) {`
	`47`	`+BXTTEST_F(BxtUsDeviceIdTest, WhenCheckingIsSimulationThenTrueReturnedOnlyForSimulationId) {`
`48`	`48`	`unsigned short bxtSimulationIds[3] = {`
`49`	`49`	`IBXT_A_DEVICE_F0_ID,`
`50`	`50`	`IBXT_C_DEVICE_F0_ID,`