From 1625efc870f1a8b7c6e6382277ddbb245f91a294 Mon Sep 17 00:00:00 2001 From: Sadik Armagan Date: Thu, 10 Jun 2021 18:24:34 +0100 Subject: IVGCVSW-5963 'Move unit tests to new framework' * Used doctest in ArmNN unit tests Signed-off-by: Sadik Armagan Change-Id: Ia9cf5fc72775878885c5f864abf2c56b3a935f1a --- src/backends/cl/test/ClContextSerializerTests.cpp | 25 +- src/backends/cl/test/ClCreateWorkloadTests.cpp | 360 +-- src/backends/cl/test/ClEndToEndTests.cpp | 366 +-- src/backends/cl/test/ClFallbackTests.cpp | 128 +- .../cl/test/ClImportTensorHandleFactoryTests.cpp | 55 +- src/backends/cl/test/ClImportTensorHandleTests.cpp | 45 +- src/backends/cl/test/ClJsonPrinterTests.cpp | 9 +- src/backends/cl/test/ClLayerSupportTests.cpp | 80 +- src/backends/cl/test/ClLayerTests.cpp | 2770 ++++++++++++-------- src/backends/cl/test/ClMemCopyTests.cpp | 24 +- src/backends/cl/test/ClOptimizedNetworkTests.cpp | 51 +- src/backends/cl/test/ClRuntimeTests.cpp | 34 +- src/backends/cl/test/Fp16SupportTest.cpp | 20 +- src/backends/cl/test/OpenClTimerTest.cpp | 19 +- 14 files changed, 2292 insertions(+), 1694 deletions(-) (limited to 'src/backends/cl') diff --git a/src/backends/cl/test/ClContextSerializerTests.cpp b/src/backends/cl/test/ClContextSerializerTests.cpp index 1fc0fb9205..1135e115e1 100644 --- a/src/backends/cl/test/ClContextSerializerTests.cpp +++ b/src/backends/cl/test/ClContextSerializerTests.cpp @@ -7,7 +7,7 @@ #include -#include +#include #include @@ -66,9 +66,7 @@ std::vector ReadBinaryFile(const std::string& binaryFileName) } // anonymous namespace -BOOST_FIXTURE_TEST_SUITE(ClContextSerializer, ClContextControlFixture) - -BOOST_AUTO_TEST_CASE(ClContextSerializerTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "ClContextSerializerTest") { // Get tmp directory and create blank file. fs::path filePath = armnnUtils::Filesystem::NamedTempFile("Armnn-CachedNetworkFileTest-TempFile.bin"); @@ -101,24 +99,24 @@ BOOST_AUTO_TEST_CASE(ClContextSerializerTest) *net1, backends, runtime->GetDeviceSpec(), optimizerOptions1); armnn::IOptimizedNetworkPtr optNet2 = armnn::Optimize( *net2, backends, runtime->GetDeviceSpec(), optimizerOptions2); - BOOST_CHECK(optNet1); - BOOST_CHECK(optNet2); + CHECK(optNet1); + CHECK(optNet2); // Cached file should be empty until net1 is loaded into runtime. - BOOST_TEST(fs::is_empty(filePathString)); + CHECK(fs::is_empty(filePathString)); // Load net1 into the runtime. armnn::NetworkId netId1; - BOOST_TEST(runtime->LoadNetwork(netId1, std::move(optNet1)) == armnn::Status::Success); + CHECK(runtime->LoadNetwork(netId1, std::move(optNet1)) == armnn::Status::Success); // File should now exist and not be empty. It has been serialized. - BOOST_TEST(fs::exists(filePathString)); + CHECK(fs::exists(filePathString)); std::vector dataSerialized = ReadBinaryFile(filePathString); - BOOST_TEST(dataSerialized.size() != 0); + CHECK(dataSerialized.size() != 0); // Load net2 into the runtime using file and deserialize. armnn::NetworkId netId2; - BOOST_TEST(runtime->LoadNetwork(netId2, std::move(optNet2)) == armnn::Status::Success); + CHECK(runtime->LoadNetwork(netId2, std::move(optNet2)) == armnn::Status::Success); // Run inference and get output data. std::vector outputData1(5); @@ -128,11 +126,8 @@ BOOST_AUTO_TEST_CASE(ClContextSerializerTest) RunInference(netId2, runtime, outputData2); // Compare outputs from both networks. - BOOST_CHECK_EQUAL_COLLECTIONS(outputData1.begin(), outputData1.end(), - outputData2.begin(), outputData2.end()); + CHECK(std::equal(outputData1.begin(), outputData1.end(), outputData2.begin(), outputData2.end())); // Remove temp file created. fs::remove(filePath); } - -BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/cl/test/ClCreateWorkloadTests.cpp b/src/backends/cl/test/ClCreateWorkloadTests.cpp index 7602cbbc0b..4e403283e7 100644 --- a/src/backends/cl/test/ClCreateWorkloadTests.cpp +++ b/src/backends/cl/test/ClCreateWorkloadTests.cpp @@ -21,14 +21,16 @@ #include #include +#include + armnn::PredicateResult CompareIClTensorHandleShape(IClTensorHandle* tensorHandle, std::initializer_list expectedDimensions) { return CompareTensorHandleShape(tensorHandle, expectedDimensions); } -BOOST_FIXTURE_TEST_SUITE(CreateWorkloadCl, ClContextControlFixture) - +TEST_SUITE("CreateWorkloadCl") +{ template static void ClCreateActivationWorkloadTest() { @@ -44,18 +46,18 @@ static void ClCreateActivationWorkloadTest() auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, {1, 1}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {1, 1}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateActivationFloatWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateActivationFloatWorkload") { ClCreateActivationWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateActivationFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateActivationFloat16Workload") { ClCreateActivationWorkloadTest(); } @@ -78,14 +80,14 @@ static void ClCreateElementwiseWorkloadTest() auto inputHandle2 = PolymorphicDowncast(queueDescriptor.m_Inputs[1]); auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle1, {2, 3}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(inputHandle2, {2, 3}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {2, 3}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateAdditionFloatWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateAdditionFloatWorkload") { ClCreateElementwiseWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateAdditionFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateAdditionFloat16Workload") { ClCreateElementwiseWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateSubtractionFloatWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSubtractionFloatWorkload") { ClCreateElementwiseWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateSubtractionFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSubtractionFloat16Workload") { ClCreateElementwiseWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateMultiplicationFloatWorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMultiplicationFloatWorkloadTest") { ClCreateElementwiseWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat16WorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMultiplicationFloat16WorkloadTest") { ClCreateElementwiseWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateMultiplicationUint8WorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMultiplicationUint8WorkloadTest") { ClCreateElementwiseWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateDivisionFloatWorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDivisionFloatWorkloadTest") { ClCreateElementwiseWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateDivisionFloat16WorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDivisionFloat16WorkloadTest") { ClCreateElementwiseWorkloadTest(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, {2, 3}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {2, 3}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateRsqrtFloat32WorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateRsqrtFloat32WorkloadTest") { ClCreateElementwiseUnaryWorkloadTest( UnaryOperation::Rsqrt); @@ -206,43 +208,43 @@ static void ClCreateBatchNormalizationWorkloadTest(DataLayout dataLayout) { case DataLayout::NHWC: predResult = CompareIClTensorHandleShape(inputHandle, { 2, 4, 4, 3 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, { 2, 4, 4, 3 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); break; default: // NCHW predResult = CompareIClTensorHandleShape(inputHandle, { 2, 3, 4, 4 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, { 2, 3, 4, 4 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } } -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloatNchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateBatchNormalizationFloatNchwWorkload") { ClCreateBatchNormalizationWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat16NchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateBatchNormalizationFloat16NchwWorkload") { ClCreateBatchNormalizationWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloatNhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateBatchNormalizationFloatNhwcWorkload") { ClCreateBatchNormalizationWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreateBatchNormalizationNhwcFloat16NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateBatchNormalizationNhwcFloat16NhwcWorkload") { ClCreateBatchNormalizationWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreateConvertFp16ToFp32Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvertFp16ToFp32Workload") { Graph graph; ClWorkloadFactory factory = @@ -254,14 +256,14 @@ BOOST_AUTO_TEST_CASE(CreateConvertFp16ToFp32Workload) auto inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[0]); auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, {1, 3, 2, 3}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {1, 3, 2, 3}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); - BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16)); - BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32)); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); + CHECK((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16)); + CHECK((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32)); } -BOOST_AUTO_TEST_CASE(CreateConvertFp32ToFp16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvertFp32ToFp16Workload") { Graph graph; ClWorkloadFactory factory = @@ -274,11 +276,11 @@ BOOST_AUTO_TEST_CASE(CreateConvertFp32ToFp16Workload) auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, {1, 3, 2, 3}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {1, 3, 2, 3}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); - BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32)); - BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16)); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); + CHECK((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32)); + CHECK((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16)); } template @@ -301,31 +303,31 @@ static void ClConvolution2dWorkloadTest(DataLayout dataLayout) Convolution2dQueueDescriptor queueDescriptor = workload->GetData(); auto inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[0]); auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); - BOOST_TEST((inputHandle->GetShape() == inputShape)); - BOOST_TEST((outputHandle->GetShape() == outputShape)); + CHECK((inputHandle->GetShape() == inputShape)); + CHECK((outputHandle->GetShape() == outputShape)); } -BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatNchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dFloatNchwWorkload") { ClConvolution2dWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatNhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dFloatNhwcWorkload") { ClConvolution2dWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16NchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dFloat16NchwWorkload") { ClConvolution2dWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dFloat16NhwcWorkload") { ClConvolution2dWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreateConvolution2dFastMathEnabledWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dFastMathEnabledWorkload") { Graph graph; @@ -353,7 +355,7 @@ BOOST_AUTO_TEST_CASE(CreateConvolution2dFastMathEnabledWorkload) ARMNN_ASSERT(conv2dWorkload->GetConvolutionMethod() == arm_compute::ConvolutionMethod::WINOGRAD); } -BOOST_AUTO_TEST_CASE(CreateConvolution2dClCompiledContextWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dClCompiledContextWorkload") { using namespace armnn; @@ -434,7 +436,7 @@ BOOST_AUTO_TEST_CASE(CreateConvolution2dClCompiledContextWorkload) // Check built programs are empty in context - BOOST_TEST(clCompileContext.get_built_programs().empty()); + CHECK(clCompileContext.get_built_programs().empty()); auto workload = std::make_unique(queueDescriptor, workloadInfo, @@ -442,7 +444,7 @@ BOOST_AUTO_TEST_CASE(CreateConvolution2dClCompiledContextWorkload) clCompileContext); ARMNN_ASSERT(workload != nullptr); // Check built programs are not empty in context - BOOST_TEST(!clCompileContext.get_built_programs().empty()); + CHECK(!clCompileContext.get_built_programs().empty()); } template @@ -465,11 +467,11 @@ static void ClDepthwiseConvolutionWorkloadTest(DataLayout dataLayout) TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list({ 2, 2, 5, 5 }) : std::initializer_list({ 2, 5, 5, 2 }); - BOOST_TEST((inputHandle->GetShape() == inputShape)); - BOOST_TEST((outputHandle->GetShape() == outputShape)); + CHECK((inputHandle->GetShape() == inputShape)); + CHECK((outputHandle->GetShape() == outputShape)); } -BOOST_AUTO_TEST_CASE(CreateDepthwiseConvolutionFloat32NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDepthwiseConvolutionFloat32NhwcWorkload") { ClDepthwiseConvolutionWorkloadTest(DataLayout::NHWC); } @@ -488,22 +490,22 @@ static void ClDirectConvolution2dWorkloadTest() auto inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[0]); auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, {2, 3, 6, 6}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {2, 2, 6, 6}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dFloatWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDirectConvolution2dFloatWorkload") { ClDirectConvolution2dWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDirectConvolution2dFloat16Workload") { ClDirectConvolution2dWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dUint8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDirectConvolution2dUint8Workload") { ClDirectConvolution2dWorkloadTest(); } @@ -523,18 +525,18 @@ static void ClCreateFullyConnectedWorkloadTest() auto inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[0]); auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, {3, 1, 4, 5}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {3, 7}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloatWorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateFullyConnectedFloatWorkloadTest") { ClCreateFullyConnectedWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloat16WorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateFullyConnectedFloat16WorkloadTest") { ClCreateFullyConnectedWorkloadTest(); } @@ -558,26 +560,26 @@ static void ClNormalizationWorkloadTest(DataLayout dataLayout) TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list({3, 5, 5, 1}) : std::initializer_list({3, 1, 5, 5}); - BOOST_TEST((inputHandle->GetShape() == inputShape)); - BOOST_TEST((outputHandle->GetShape() == outputShape)); + CHECK((inputHandle->GetShape() == inputShape)); + CHECK((outputHandle->GetShape() == outputShape)); } -BOOST_AUTO_TEST_CASE(CreateNormalizationFloat32NchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateNormalizationFloat32NchwWorkload") { ClNormalizationWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateNormalizationFloat16NchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateNormalizationFloat16NchwWorkload") { ClNormalizationWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateNormalizationFloat32NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateNormalizationFloat32NhwcWorkload") { ClNormalizationWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreateNormalizationFloat16NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateNormalizationFloat16NhwcWorkload") { ClNormalizationWorkloadTest(DataLayout::NHWC); } @@ -601,26 +603,26 @@ static void ClPooling2dWorkloadTest(DataLayout dataLayout) auto inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[0]); auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); - BOOST_TEST((inputHandle->GetShape() == inputShape)); - BOOST_TEST((outputHandle->GetShape() == outputShape)); + CHECK((inputHandle->GetShape() == inputShape)); + CHECK((outputHandle->GetShape() == outputShape)); } -BOOST_AUTO_TEST_CASE(CreatePooling2dFloatNchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePooling2dFloatNchwWorkload") { ClPooling2dWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreatePooling2dFloatNhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePooling2dFloatNhwcWorkload") { ClPooling2dWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16NchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePooling2dFloat16NchwWorkload") { ClPooling2dWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePooling2dFloat16NhwcWorkload") { ClPooling2dWorkloadTest(DataLayout::NHWC); } @@ -647,22 +649,22 @@ static void ClCreatePreluWorkloadTest(const armnn::TensorShape& inputShape, auto alphaHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[1]); auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); - BOOST_TEST((inputHandle->GetShape() == inputShape)); - BOOST_TEST((alphaHandle->GetShape() == alphaShape)); - BOOST_TEST((outputHandle->GetShape() == outputShape)); + CHECK((inputHandle->GetShape() == inputShape)); + CHECK((alphaHandle->GetShape() == alphaShape)); + CHECK((outputHandle->GetShape() == outputShape)); } -BOOST_AUTO_TEST_CASE(CreatePreluFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePreluFloat16Workload") { ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float16); } -BOOST_AUTO_TEST_CASE(CreatePreluFloatWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePreluFloatWorkload") { ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float32); } -BOOST_AUTO_TEST_CASE(CreatePreluUint8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePreluUint8Workload") { ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::QAsymmU8); } @@ -682,22 +684,22 @@ static void ClCreateReshapeWorkloadTest() auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, {4, 1}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {1, 4}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateReshapeFloatWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateReshapeFloatWorkload") { ClCreateReshapeWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateReshapeFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateReshapeFloat16Workload") { ClCreateReshapeWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateReshapeUint8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateReshapeUint8Workload") { ClCreateReshapeWorkloadTest(); } @@ -729,28 +731,28 @@ static void ClSoftmaxWorkloadTest() } auto predResult = CompareIClTensorHandleShape(inputHandle, {4, 1}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {4, 1}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat32WorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSoftmaxFloat32WorkloadTest") { ClSoftmaxWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat16WorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSoftmaxFloat16WorkloadTest") { ClSoftmaxWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateSoftmaxQAsymmU8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSoftmaxQAsymmU8Workload") { ClSoftmaxWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateSoftmaxQAsymmS8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSoftmaxQAsymmS8Workload") { ClSoftmaxWorkloadTest(); } @@ -768,27 +770,27 @@ static void ClSplitterWorkloadTest() SplitterQueueDescriptor queueDescriptor = workload->GetData(); auto inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, {5, 7, 7}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); auto outputHandle1 = PolymorphicDowncast(queueDescriptor.m_Outputs[1]); predResult = CompareIClTensorHandleShape(outputHandle1, {2, 7, 7}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); auto outputHandle2 = PolymorphicDowncast(queueDescriptor.m_Outputs[2]); predResult = CompareIClTensorHandleShape(outputHandle2, {2, 7, 7}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); auto outputHandle0 = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); predResult = CompareIClTensorHandleShape(outputHandle0, {1, 7, 7}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateSplitterFloatWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSplitterFloatWorkload") { ClSplitterWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateSplitterFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSplitterFloat16Workload") { ClSplitterWorkloadTest(); } @@ -819,35 +821,35 @@ static void ClSplitterConcatTest() armnn::ClSubTensorHandle* mIn0 = dynamic_cast(wlConcat->GetData().m_Inputs[0]); armnn::ClSubTensorHandle* mIn1 = dynamic_cast(wlConcat->GetData().m_Inputs[1]); - BOOST_TEST(sOut0); - BOOST_TEST(sOut1); - BOOST_TEST(mIn0); - BOOST_TEST(mIn1); + CHECK(sOut0); + CHECK(sOut1); + CHECK(mIn0); + CHECK(mIn1); //Fliped order of inputs/outputs. bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0); - BOOST_TEST(validDataPointers); + CHECK(validDataPointers); //Also make sure that the inputs are subtensors of one tensor and outputs are sub tensors of another tensor. bool validSubTensorParents = (mIn0->GetTensor().parent() == mIn1->GetTensor().parent()) && (sOut0->GetTensor().parent() == sOut1->GetTensor().parent()); - BOOST_TEST(validSubTensorParents); + CHECK(validSubTensorParents); } -BOOST_AUTO_TEST_CASE(CreateSplitterConcatFloatWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSplitterConcatFloatWorkload") { ClSplitterConcatTest(); } -BOOST_AUTO_TEST_CASE(CreateSplitterConcatFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSplitterConcatFloat16Workload") { ClSplitterConcatTest(); } -BOOST_AUTO_TEST_CASE(CreateSingleOutputMultipleInputs) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSingleOutputMultipleInputs") { // Test that it is possible to assign multiple (two) different layers to each of the outputs of a splitter layer. // We create a splitter with two outputs. That each of those outputs is used by two different activation layers. @@ -875,24 +877,24 @@ BOOST_AUTO_TEST_CASE(CreateSingleOutputMultipleInputs) armnn::ClSubTensorHandle* activ1_1Im = dynamic_cast(wlActiv1_1->GetData().m_Inputs[0]); - BOOST_TEST(sOut0); - BOOST_TEST(sOut1); - BOOST_TEST(activ0_0Im); - BOOST_TEST(activ0_1Im); - BOOST_TEST(activ1_0Im); - BOOST_TEST(activ1_1Im); + CHECK(sOut0); + CHECK(sOut1); + CHECK(activ0_0Im); + CHECK(activ0_1Im); + CHECK(activ1_0Im); + CHECK(activ1_1Im); bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) && (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im); - BOOST_TEST(validDataPointers); + CHECK(validDataPointers); } #if defined(ARMNNREF_ENABLED) // This test unit needs the reference backend, it's not available if the reference backend is not built -BOOST_AUTO_TEST_CASE(CreateMemCopyWorkloadsCl) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMemCopyWorkloadsCl") { ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager()); @@ -922,26 +924,26 @@ static void ClL2NormalizationWorkloadTest(DataLayout dataLayout) TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list({ 5, 20, 50, 67 }) : std::initializer_list({ 5, 50, 67, 20 }); - BOOST_TEST((inputHandle->GetShape() == inputShape)); - BOOST_TEST((outputHandle->GetShape() == outputShape)); + CHECK((inputHandle->GetShape() == inputShape)); + CHECK((outputHandle->GetShape() == outputShape)); } -BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloatNchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateL2NormalizationFloatNchwWorkload") { ClL2NormalizationWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloatNhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateL2NormalizationFloatNhwcWorkload") { ClL2NormalizationWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloat16NchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateL2NormalizationFloat16NchwWorkload") { ClL2NormalizationWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloat16NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateL2NormalizationFloat16NhwcWorkload") { ClL2NormalizationWorkloadTest(DataLayout::NHWC); } @@ -961,12 +963,12 @@ static void ClCreateLogSoftmaxWorkloadTest() auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, {4, 1}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {4, 1}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateLogSoftmaxFloat32WorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateLogSoftmaxFloat32WorkloadTest") { ClCreateLogSoftmaxWorkloadTest(); } @@ -984,12 +986,12 @@ static void ClCreateLstmWorkloadTest() auto inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[0]); auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[1]); auto predResult = CompareIClTensorHandleShape(inputHandle, {2, 2}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, {2, 4}); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateLSTMWorkloadFloatWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateLSTMWorkloadFloatWorkload") { ClCreateLstmWorkloadTest(); } @@ -1013,44 +1015,44 @@ static void ClResizeWorkloadTest(DataLayout dataLayout) { case DataLayout::NHWC: predResult = CompareIClTensorHandleShape(inputHandle, { 2, 4, 4, 3 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, { 2, 2, 2, 3 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); break; default: // DataLayout::NCHW predResult = CompareIClTensorHandleShape(inputHandle, { 2, 3, 4, 4 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, { 2, 3, 2, 2 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } } -BOOST_AUTO_TEST_CASE(CreateResizeFloat32NchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeFloat32NchwWorkload") { ClResizeWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateResizeFloat16NchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeFloat16NchwWorkload") { ClResizeWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateResizeUint8NchwWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeUint8NchwWorkload") { ClResizeWorkloadTest(DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(CreateResizeFloat32NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeFloat32NhwcWorkload") { ClResizeWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreateResizeFloat16NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeFloat16NhwcWorkload") { ClResizeWorkloadTest(DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(CreateResizeUint8NhwcWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeUint8NhwcWorkload") { ClResizeWorkloadTest(DataLayout::NHWC); } @@ -1071,22 +1073,22 @@ static void ClMeanWorkloadTest() // The first dimension (batch size) in both input and output is singular thus it has been reduced by ACL. auto predResult = CompareIClTensorHandleShape(inputHandle, { 1, 3, 7, 4 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, { 1, 4 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateMeanFloat32Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMeanFloat32Workload") { ClMeanWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateMeanFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMeanFloat16Workload") { ClMeanWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateMeanUint8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMeanUint8Workload") { ClMeanWorkloadTest(); } @@ -1107,39 +1109,39 @@ static void ClCreateConcatWorkloadTest(std::initializer_list outpu auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle0, { 2, 3, 2, 5 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(inputHandle1, { 2, 3, 2, 5 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, outputShape); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateConcatDim0Float32Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim0Float32Workload") { ClCreateConcatWorkloadTest({ 4, 3, 2, 5 }, 0); } -BOOST_AUTO_TEST_CASE(CreateConcatDim1Float32Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim1Float32Workload") { ClCreateConcatWorkloadTest({ 2, 6, 2, 5 }, 1); } -BOOST_AUTO_TEST_CASE(CreateConcatDim3Float32Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim3Float32Workload") { ClCreateConcatWorkloadTest({ 2, 3, 2, 10 }, 3); } -BOOST_AUTO_TEST_CASE(CreateConcatDim0Uint8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim0Uint8Workload") { ClCreateConcatWorkloadTest({ 4, 3, 2, 5 }, 0); } -BOOST_AUTO_TEST_CASE(CreateConcatDim1Uint8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim1Uint8Workload") { ClCreateConcatWorkloadTest({ 2, 6, 2, 5 }, 1); } -BOOST_AUTO_TEST_CASE(CreateConcatDim3Uint8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim3Uint8Workload") { ClCreateConcatWorkloadTest({ 2, 3, 2, 10 }, 3); } @@ -1158,27 +1160,27 @@ static void ClSpaceToDepthWorkloadTest() auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult = CompareIClTensorHandleShape(inputHandle, { 1, 2, 2, 1 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); predResult = CompareIClTensorHandleShape(outputHandle, { 1, 1, 1, 4 }); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateSpaceToDepthFloat32Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSpaceToDepthFloat32Workload") { ClSpaceToDepthWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateSpaceToDepthFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSpaceToDepthFloat16Workload") { ClSpaceToDepthWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateSpaceToDepthQAsymm8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSpaceToDepthQAsymm8Workload") { ClSpaceToDepthWorkloadTest(); } -BOOST_AUTO_TEST_CASE(CreateSpaceToDepthQSymm16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSpaceToDepthQSymm16Workload") { ClSpaceToDepthWorkloadTest(); } @@ -1206,24 +1208,24 @@ static void ClCreateStackWorkloadTest(const std::initializer_list& { auto inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[i]); auto predResult1 = CompareIClTensorHandleShape(inputHandle, inputShape); - BOOST_TEST(predResult1.m_Result, predResult1.m_Message.str()); + CHECK_MESSAGE(predResult1.m_Result, predResult1.m_Message.str()); } auto outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); auto predResult2 = CompareIClTensorHandleShape(outputHandle, outputShape); - BOOST_TEST(predResult2.m_Result, predResult2.m_Message.str()); + CHECK_MESSAGE(predResult2.m_Result, predResult2.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CreateStackFloat32Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateStackFloat32Workload") { ClCreateStackWorkloadTest({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2); } -BOOST_AUTO_TEST_CASE(CreateStackFloat16Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateStackFloat16Workload") { ClCreateStackWorkloadTest({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2); } -BOOST_AUTO_TEST_CASE(CreateStackUint8Workload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateStackUint8Workload") { ClCreateStackWorkloadTest({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2); } @@ -1239,19 +1241,19 @@ static void ClCreateQLstmWorkloadTest() QLstmQueueDescriptor queueDescriptor = workload->GetData(); IAclTensorHandle* inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[0]); - BOOST_TEST((inputHandle->GetShape() == TensorShape({2, 4}))); - BOOST_TEST((inputHandle->GetDataType() == arm_compute::DataType::QASYMM8_SIGNED)); + CHECK((inputHandle->GetShape() == TensorShape({2, 4}))); + CHECK((inputHandle->GetDataType() == arm_compute::DataType::QASYMM8_SIGNED)); IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[1]); - BOOST_TEST((cellStateOutHandle->GetShape() == TensorShape({2, 4}))); - BOOST_TEST((cellStateOutHandle->GetDataType() == arm_compute::DataType::QSYMM16)); + CHECK((cellStateOutHandle->GetShape() == TensorShape({2, 4}))); + CHECK((cellStateOutHandle->GetDataType() == arm_compute::DataType::QSYMM16)); IAclTensorHandle* outputHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[2]); - BOOST_TEST((outputHandle->GetShape() == TensorShape({2, 4}))); - BOOST_TEST((outputHandle->GetDataType() == arm_compute::DataType::QASYMM8_SIGNED)); + CHECK((outputHandle->GetShape() == TensorShape({2, 4}))); + CHECK((outputHandle->GetDataType() == arm_compute::DataType::QASYMM8_SIGNED)); } -BOOST_AUTO_TEST_CASE(CreateQLstmWorkloadTest) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateQLstmWorkloadTest") { ClCreateQLstmWorkloadTest(); } @@ -1270,29 +1272,29 @@ static void ClCreateQuantizedLstmWorkloadTest() QuantizedLstmQueueDescriptor queueDescriptor = workload->GetData(); IAclTensorHandle* inputHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[0]); - BOOST_TEST((inputHandle->GetShape() == TensorShape({2, 2}))); - BOOST_TEST((inputHandle->GetDataType() == arm_compute::DataType::QASYMM8)); + CHECK((inputHandle->GetShape() == TensorShape({2, 2}))); + CHECK((inputHandle->GetDataType() == arm_compute::DataType::QASYMM8)); IAclTensorHandle* cellStateInHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[1]); - BOOST_TEST((cellStateInHandle->GetShape() == TensorShape({2, 4}))); - BOOST_TEST((cellStateInHandle->GetDataType() == arm_compute::DataType::QSYMM16)); + CHECK((cellStateInHandle->GetShape() == TensorShape({2, 4}))); + CHECK((cellStateInHandle->GetDataType() == arm_compute::DataType::QSYMM16)); IAclTensorHandle* outputStateInHandle = PolymorphicDowncast(queueDescriptor.m_Inputs[2]); - BOOST_TEST((outputStateInHandle->GetShape() == TensorShape({2, 4}))); - BOOST_TEST((outputStateInHandle->GetDataType() == arm_compute::DataType::QASYMM8)); + CHECK((outputStateInHandle->GetShape() == TensorShape({2, 4}))); + CHECK((outputStateInHandle->GetDataType() == arm_compute::DataType::QASYMM8)); IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[0]); - BOOST_TEST((cellStateOutHandle->GetShape() == TensorShape({2, 4}))); - BOOST_TEST((cellStateOutHandle->GetDataType() == arm_compute::DataType::QSYMM16)); + CHECK((cellStateOutHandle->GetShape() == TensorShape({2, 4}))); + CHECK((cellStateOutHandle->GetDataType() == arm_compute::DataType::QSYMM16)); IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast(queueDescriptor.m_Outputs[1]); - BOOST_TEST((outputStateOutHandle->GetShape() == TensorShape({2, 4}))); - BOOST_TEST((outputStateOutHandle->GetDataType() == arm_compute::DataType::QASYMM8)); + CHECK((outputStateOutHandle->GetShape() == TensorShape({2, 4}))); + CHECK((outputStateOutHandle->GetDataType() == arm_compute::DataType::QASYMM8)); } -BOOST_AUTO_TEST_CASE(CreateQuantizedLstmWorkload) +TEST_CASE_FIXTURE(ClContextControlFixture, "CreateQuantizedLstmWorkload") { ClCreateQuantizedLstmWorkloadTest(); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/ClEndToEndTests.cpp b/src/backends/cl/test/ClEndToEndTests.cpp index edee368fa9..9e0137eb37 100644 --- a/src/backends/cl/test/ClEndToEndTests.cpp +++ b/src/backends/cl/test/ClEndToEndTests.cpp @@ -21,14 +21,14 @@ #include #include -#include +#include -BOOST_AUTO_TEST_SUITE(ClEndToEnd) - -std::vector defaultBackends = {armnn::Compute::GpuAcc}; +TEST_SUITE("ClEndToEnd") +{ +std::vector clDefaultBackends = {armnn::Compute::GpuAcc}; // Abs -BOOST_AUTO_TEST_CASE(ClAbsEndToEndTestFloat32) +TEST_CASE("ClAbsEndToEndTestFloat32") { std::vector expectedOutput = { @@ -36,482 +36,482 @@ BOOST_AUTO_TEST_CASE(ClAbsEndToEndTestFloat32) 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f }; - ElementwiseUnarySimpleEndToEnd(defaultBackends, + ElementwiseUnarySimpleEndToEnd(clDefaultBackends, UnaryOperation::Abs, expectedOutput); } // Constant -BOOST_AUTO_TEST_CASE(ConstantUsage_Cl_Float32) +TEST_CASE("ConstantUsage_Cl_Float32") { - ConstantUsageFloat32Test(defaultBackends); + ConstantUsageFloat32Test(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim0Test) +TEST_CASE("ClConcatEndToEndDim0Test") { - ConcatDim0EndToEnd(defaultBackends); + ConcatDim0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim0Uint8Test) +TEST_CASE("ClConcatEndToEndDim0Uint8Test") { - ConcatDim0EndToEnd(defaultBackends); + ConcatDim0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Test) +TEST_CASE("ClConcatEndToEndDim1Test") { - ConcatDim1EndToEnd(defaultBackends); + ConcatDim1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Uint8Test) +TEST_CASE("ClConcatEndToEndDim1Uint8Test") { - ConcatDim1EndToEnd(defaultBackends); + ConcatDim1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Test) +TEST_CASE("ClConcatEndToEndDim3Test") { - ConcatDim3EndToEnd(defaultBackends); + ConcatDim3EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Uint8Test) +TEST_CASE("ClConcatEndToEndDim3Uint8Test") { - ConcatDim3EndToEnd(defaultBackends); + ConcatDim3EndToEnd(clDefaultBackends); } // DepthToSpace -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat32) +TEST_CASE("DephtToSpaceEndToEndNchwFloat32") { - DepthToSpaceEndToEnd(defaultBackends, armnn::DataLayout::NCHW); + DepthToSpaceEndToEnd(clDefaultBackends, armnn::DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat16) +TEST_CASE("DephtToSpaceEndToEndNchwFloat16") { - DepthToSpaceEndToEnd(defaultBackends, armnn::DataLayout::NCHW); + DepthToSpaceEndToEnd(clDefaultBackends, armnn::DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwUint8) +TEST_CASE("DephtToSpaceEndToEndNchwUint8") { - DepthToSpaceEndToEnd(defaultBackends, armnn::DataLayout::NCHW); + DepthToSpaceEndToEnd(clDefaultBackends, armnn::DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwInt16) +TEST_CASE("DephtToSpaceEndToEndNchwInt16") { - DepthToSpaceEndToEnd(defaultBackends, armnn::DataLayout::NCHW); + DepthToSpaceEndToEnd(clDefaultBackends, armnn::DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat32) +TEST_CASE("DephtToSpaceEndToEndNhwcFloat32") { - DepthToSpaceEndToEnd(defaultBackends, armnn::DataLayout::NHWC); + DepthToSpaceEndToEnd(clDefaultBackends, armnn::DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat16) +TEST_CASE("DephtToSpaceEndToEndNhwcFloat16") { - DepthToSpaceEndToEnd(defaultBackends, armnn::DataLayout::NHWC); + DepthToSpaceEndToEnd(clDefaultBackends, armnn::DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcUint8) +TEST_CASE("DephtToSpaceEndToEndNhwcUint8") { - DepthToSpaceEndToEnd(defaultBackends, armnn::DataLayout::NHWC); + DepthToSpaceEndToEnd(clDefaultBackends, armnn::DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcInt16) +TEST_CASE("DephtToSpaceEndToEndNhwcInt16") { - DepthToSpaceEndToEnd(defaultBackends, armnn::DataLayout::NHWC); + DepthToSpaceEndToEnd(clDefaultBackends, armnn::DataLayout::NHWC); } // Dequantize -BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest) +TEST_CASE("DequantizeEndToEndSimpleTest") { - DequantizeEndToEndSimple(defaultBackends); + DequantizeEndToEndSimple(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(DequantizeEndToEndOffsetTest) +TEST_CASE("DequantizeEndToEndOffsetTest") { - DequantizeEndToEndOffset(defaultBackends); + DequantizeEndToEndOffset(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClStridedSliceInvalidSliceEndToEndTest) +TEST_CASE("ClStridedSliceInvalidSliceEndToEndTest") { - StridedSliceInvalidSliceEndToEndTest(defaultBackends); + StridedSliceInvalidSliceEndToEndTest(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClEluEndToEndTestFloat32) +TEST_CASE("ClEluEndToEndTestFloat32") { - EluEndToEndTest(defaultBackends); + EluEndToEndTest(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClEluEndToEndTestFloat16) +TEST_CASE("ClEluEndToEndTestFloat16") { - EluEndToEndTest(defaultBackends); + EluEndToEndTest(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndTest) +TEST_CASE("ClGreaterSimpleEndToEndTest") { const std::vector expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }); - ComparisonSimpleEndToEnd(defaultBackends, + ComparisonSimpleEndToEnd(clDefaultBackends, ComparisonOperation::Greater, expectedOutput); } -BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndUint8Test) +TEST_CASE("ClGreaterSimpleEndToEndUint8Test") { const std::vector expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }); - ComparisonSimpleEndToEnd(defaultBackends, + ComparisonSimpleEndToEnd(clDefaultBackends, ComparisonOperation::Greater, expectedOutput); } -BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndTest) +TEST_CASE("ClGreaterBroadcastEndToEndTest") { const std::vector expectedOutput({ 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 }); - ComparisonBroadcastEndToEnd(defaultBackends, + ComparisonBroadcastEndToEnd(clDefaultBackends, ComparisonOperation::Greater, expectedOutput); } -BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndUint8Test) +TEST_CASE("ClGreaterBroadcastEndToEndUint8Test") { const std::vector expectedOutput({ 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 }); - ComparisonBroadcastEndToEnd(defaultBackends, + ComparisonBroadcastEndToEnd(clDefaultBackends, ComparisonOperation::Greater, expectedOutput); } // HardSwish -BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestFloat32) +TEST_CASE("ClHardSwishEndToEndTestFloat32") { - HardSwishEndToEndTest(defaultBackends); + HardSwishEndToEndTest(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestFloat16) +TEST_CASE("ClHardSwishEndToEndTestFloat16") { - HardSwishEndToEndTest(defaultBackends); + HardSwishEndToEndTest(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQAsymmS8) +TEST_CASE("ClHardSwishEndToEndTestQAsymmS8") { - HardSwishEndToEndTest(defaultBackends); + HardSwishEndToEndTest(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQAsymmU8) +TEST_CASE("ClHardSwishEndToEndTestQAsymmU8") { - HardSwishEndToEndTest(defaultBackends); + HardSwishEndToEndTest(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQSymmS16) +TEST_CASE("ClHardSwishEndToEndTestQSymmS16") { - HardSwishEndToEndTest(defaultBackends); + HardSwishEndToEndTest(clDefaultBackends); } // InstanceNormalization -BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNhwcEndToEndTest1) +TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest1") { - InstanceNormalizationNhwcEndToEndTest1(defaultBackends); + InstanceNormalizationNhwcEndToEndTest1(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNchwEndToEndTest1) +TEST_CASE("ClInstanceNormalizationNchwEndToEndTest1") { - InstanceNormalizationNchwEndToEndTest1(defaultBackends); + InstanceNormalizationNchwEndToEndTest1(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNhwcEndToEndTest2) +TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest2") { - InstanceNormalizationNhwcEndToEndTest2(defaultBackends); + InstanceNormalizationNhwcEndToEndTest2(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNchwEndToEndTest2) +TEST_CASE("ClInstanceNormalizationNchwEndToEndTest2") { - InstanceNormalizationNchwEndToEndTest2(defaultBackends); + InstanceNormalizationNchwEndToEndTest2(clDefaultBackends); } // Fill -BOOST_AUTO_TEST_CASE(ClFillEndToEndTest) +TEST_CASE("ClFillEndToEndTest") { - FillEndToEnd(defaultBackends); + FillEndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(RefFillEndToEndTestFloat16) +TEST_CASE("RefFillEndToEndTestFloat16") { - FillEndToEnd(defaultBackends); + FillEndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClFillEndToEndTestInt32) +TEST_CASE("ClFillEndToEndTestInt32") { - FillEndToEnd(defaultBackends); + FillEndToEnd(clDefaultBackends); } // Prelu -BOOST_AUTO_TEST_CASE(ClPreluEndToEndFloat32Test) +TEST_CASE("ClPreluEndToEndFloat32Test") { - PreluEndToEndNegativeTest(defaultBackends); + PreluEndToEndNegativeTest(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClPreluEndToEndTestUint8) +TEST_CASE("ClPreluEndToEndTestUint8") { - PreluEndToEndPositiveTest(defaultBackends); + PreluEndToEndPositiveTest(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest1) +TEST_CASE("ClSpaceToDepthNhwcEndToEndTest1") { - SpaceToDepthNhwcEndToEndTest1(defaultBackends); + SpaceToDepthNhwcEndToEndTest1(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest1) +TEST_CASE("ClSpaceToDepthNchwEndToEndTest1") { - SpaceToDepthNchwEndToEndTest1(defaultBackends); + SpaceToDepthNchwEndToEndTest1(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest2) +TEST_CASE("ClSpaceToDepthNhwcEndToEndTest2") { - SpaceToDepthNhwcEndToEndTest2(defaultBackends); + SpaceToDepthNhwcEndToEndTest2(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest2) +TEST_CASE("ClSpaceToDepthNchwEndToEndTest2") { - SpaceToDepthNchwEndToEndTest2(defaultBackends); + SpaceToDepthNchwEndToEndTest2(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndTest) +TEST_CASE("ClSplitter1dEndToEndTest") { - Splitter1dEndToEnd(defaultBackends); + Splitter1dEndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndUint8Test) +TEST_CASE("ClSplitter1dEndToEndUint8Test") { - Splitter1dEndToEnd(defaultBackends); + Splitter1dEndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndTest) +TEST_CASE("ClSplitter2dDim0EndToEndTest") { - Splitter2dDim0EndToEnd(defaultBackends); + Splitter2dDim0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndTest) +TEST_CASE("ClSplitter2dDim1EndToEndTest") { - Splitter2dDim1EndToEnd(defaultBackends); + Splitter2dDim1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndUint8Test) +TEST_CASE("ClSplitter2dDim0EndToEndUint8Test") { - Splitter2dDim0EndToEnd(defaultBackends); + Splitter2dDim0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndUint8Test) +TEST_CASE("ClSplitter2dDim1EndToEndUint8Test") { - Splitter2dDim1EndToEnd(defaultBackends); + Splitter2dDim1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndTest) +TEST_CASE("ClSplitter3dDim0EndToEndTest") { - Splitter3dDim0EndToEnd(defaultBackends); + Splitter3dDim0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndTest) +TEST_CASE("ClSplitter3dDim1EndToEndTest") { - Splitter3dDim1EndToEnd(defaultBackends); + Splitter3dDim1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndTest) +TEST_CASE("ClSplitter3dDim2EndToEndTest") { - Splitter3dDim2EndToEnd(defaultBackends); + Splitter3dDim2EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndUint8Test) +TEST_CASE("ClSplitter3dDim0EndToEndUint8Test") { - Splitter3dDim0EndToEnd(defaultBackends); + Splitter3dDim0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndUint8Test) +TEST_CASE("ClSplitter3dDim1EndToEndUint8Test") { - Splitter3dDim1EndToEnd(defaultBackends); + Splitter3dDim1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndUint8Test) +TEST_CASE("ClSplitter3dDim2EndToEndUint8Test") { - Splitter3dDim2EndToEnd(defaultBackends); + Splitter3dDim2EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndTest) +TEST_CASE("ClSplitter4dDim0EndToEndTest") { - Splitter4dDim0EndToEnd(defaultBackends); + Splitter4dDim0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndTest) +TEST_CASE("ClSplitter4dDim1EndToEndTest") { - Splitter4dDim1EndToEnd(defaultBackends); + Splitter4dDim1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndTest) +TEST_CASE("ClSplitter4dDim2EndToEndTest") { - Splitter4dDim2EndToEnd(defaultBackends); + Splitter4dDim2EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndTest) +TEST_CASE("ClSplitter4dDim3EndToEndTest") { - Splitter4dDim3EndToEnd(defaultBackends); + Splitter4dDim3EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndUint8Test) +TEST_CASE("ClSplitter4dDim0EndToEndUint8Test") { - Splitter4dDim0EndToEnd(defaultBackends); + Splitter4dDim0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndUint8Test) +TEST_CASE("ClSplitter4dDim1EndToEndUint8Test") { - Splitter4dDim1EndToEnd(defaultBackends); + Splitter4dDim1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndUint8Test) +TEST_CASE("ClSplitter4dDim2EndToEndUint8Test") { - Splitter4dDim2EndToEnd(defaultBackends); + Splitter4dDim2EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndUint8Test) +TEST_CASE("ClSplitter4dDim3EndToEndUint8Test") { - Splitter4dDim3EndToEnd(defaultBackends); + Splitter4dDim3EndToEnd(clDefaultBackends); } // TransposeConvolution2d -BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNchwTest) +TEST_CASE("ClTransposeConvolution2dEndToEndFloatNchwTest") { TransposeConvolution2dEndToEnd( - defaultBackends, armnn::DataLayout::NCHW); + clDefaultBackends, armnn::DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NchwTest) +TEST_CASE("ClTransposeConvolution2dEndToEndUint8NchwTest") { TransposeConvolution2dEndToEnd( - defaultBackends, armnn::DataLayout::NCHW); + clDefaultBackends, armnn::DataLayout::NCHW); } -BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNhwcTest) +TEST_CASE("ClTransposeConvolution2dEndToEndFloatNhwcTest") { TransposeConvolution2dEndToEnd( - defaultBackends, armnn::DataLayout::NHWC); + clDefaultBackends, armnn::DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NhwcTest) +TEST_CASE("ClTransposeConvolution2dEndToEndUint8NhwcTest") { TransposeConvolution2dEndToEnd( - defaultBackends, armnn::DataLayout::NHWC); + clDefaultBackends, armnn::DataLayout::NHWC); } -BOOST_AUTO_TEST_CASE(ClQuantizedLstmEndToEndTest) +TEST_CASE("ClQuantizedLstmEndToEndTest") { - QuantizedLstmEndToEnd(defaultBackends); + QuantizedLstmEndToEnd(clDefaultBackends); } // ArgMinMax -BOOST_AUTO_TEST_CASE(ClArgMaxSimpleTest) +TEST_CASE("ClArgMaxSimpleTest") { - ArgMaxEndToEndSimple(defaultBackends); + ArgMaxEndToEndSimple(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinSimpleTest) +TEST_CASE("ClArgMinSimpleTest") { - ArgMinEndToEndSimple(defaultBackends); + ArgMinEndToEndSimple(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMaxAxis0Test) +TEST_CASE("ClArgMaxAxis0Test") { - ArgMaxAxis0EndToEnd(defaultBackends); + ArgMaxAxis0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinAxis0Test) +TEST_CASE("ClArgMinAxis0Test") { - ArgMinAxis0EndToEnd(defaultBackends); + ArgMinAxis0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMaxAxis1Test) +TEST_CASE("ClArgMaxAxis1Test") { - ArgMaxAxis1EndToEnd(defaultBackends); + ArgMaxAxis1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinAxis1Test) +TEST_CASE("ClArgMinAxis1Test") { - ArgMinAxis1EndToEnd(defaultBackends); + ArgMinAxis1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMaxAxis2Test) +TEST_CASE("ClArgMaxAxis2Test") { - ArgMaxAxis2EndToEnd(defaultBackends); + ArgMaxAxis2EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinAxis2Test) +TEST_CASE("ClArgMinAxis2Test") { - ArgMinAxis2EndToEnd(defaultBackends); + ArgMinAxis2EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMaxAxis3Test) +TEST_CASE("ClArgMaxAxis3Test") { - ArgMaxAxis3EndToEnd(defaultBackends); + ArgMaxAxis3EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinAxis3Test) +TEST_CASE("ClArgMinAxis3Test") { - ArgMinAxis3EndToEnd(defaultBackends); + ArgMinAxis3EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMaxSimpleTestQAsymmU8) +TEST_CASE("ClArgMaxSimpleTestQAsymmU8") { - ArgMaxEndToEndSimple(defaultBackends); + ArgMaxEndToEndSimple(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinSimpleTestQAsymmU8) +TEST_CASE("ClArgMinSimpleTestQAsymmU8") { - ArgMinEndToEndSimple(defaultBackends); + ArgMinEndToEndSimple(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMaxAxis0TestQAsymmU8) +TEST_CASE("ClArgMaxAxis0TestQAsymmU8") { - ArgMaxAxis0EndToEnd(defaultBackends); + ArgMaxAxis0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinAxis0TestQAsymmU8) +TEST_CASE("ClArgMinAxis0TestQAsymmU8") { - ArgMinAxis0EndToEnd(defaultBackends); + ArgMinAxis0EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMaxAxis1TestQAsymmU8) +TEST_CASE("ClArgMaxAxis1TestQAsymmU8") { - ArgMaxAxis1EndToEnd(defaultBackends); + ArgMaxAxis1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinAxis1TestQAsymmU8) +TEST_CASE("ClArgMinAxis1TestQAsymmU8") { - ArgMinAxis1EndToEnd(defaultBackends); + ArgMinAxis1EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMaxAxis2TestQAsymmU8) +TEST_CASE("ClArgMaxAxis2TestQAsymmU8") { - ArgMaxAxis2EndToEnd(defaultBackends); + ArgMaxAxis2EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinAxis2TestQAsymmU8) +TEST_CASE("ClArgMinAxis2TestQAsymmU8") { - ArgMinAxis2EndToEnd(defaultBackends); + ArgMinAxis2EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMaxAxis3TestQAsymmU8) +TEST_CASE("ClArgMaxAxis3TestQAsymmU8") { - ArgMaxAxis3EndToEnd(defaultBackends); + ArgMaxAxis3EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClArgMinAxis3TestQAsymmU8) +TEST_CASE("ClArgMinAxis3TestQAsymmU8") { - ArgMinAxis3EndToEnd(defaultBackends); + ArgMinAxis3EndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_CASE(ClQLstmEndToEndTest) +TEST_CASE("ClQLstmEndToEndTest") { - QLstmEndToEnd(defaultBackends); + QLstmEndToEnd(clDefaultBackends); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/ClFallbackTests.cpp b/src/backends/cl/test/ClFallbackTests.cpp index 183b8caa2e..7721206d3d 100644 --- a/src/backends/cl/test/ClFallbackTests.cpp +++ b/src/backends/cl/test/ClFallbackTests.cpp @@ -7,11 +7,11 @@ #include -#include +#include -BOOST_AUTO_TEST_SUITE(ClFallback) - -BOOST_AUTO_TEST_CASE(ClImportEnabledFallbackToNeon) +TEST_SUITE("ClFallback") +{ +TEST_CASE("ClImportEnabledFallbackToNeon") { using namespace armnn; @@ -62,18 +62,18 @@ BOOST_AUTO_TEST_CASE(ClImportEnabledFallbackToNeon) armnn::Layer* const layer6 = GetFirstLayerWithName(graph, "output"); // Checks order is valid. - BOOST_TEST(CheckOrder(graph, layer0, layer1)); - BOOST_TEST(CheckOrder(graph, layer1, layer2)); - BOOST_TEST(CheckOrder(graph, layer2, layer3)); - BOOST_TEST(CheckOrder(graph, layer3, layer4)); - BOOST_TEST(CheckOrder(graph, layer4, layer5)); - BOOST_TEST(CheckOrder(graph, layer5, layer6)); + CHECK(CheckOrder(graph, layer0, layer1)); + CHECK(CheckOrder(graph, layer1, layer2)); + CHECK(CheckOrder(graph, layer2, layer3)); + CHECK(CheckOrder(graph, layer3, layer4)); + CHECK(CheckOrder(graph, layer4, layer5)); + CHECK(CheckOrder(graph, layer5, layer6)); // Use memory import between backends - BOOST_TEST((layer4->GetType() == LayerType::MemCopy)); + CHECK((layer4->GetType() == LayerType::MemCopy)); // Correctly use backend hint - BOOST_TEST((layer5->GetBackendId() == Compute::CpuAcc )); + CHECK((layer5->GetBackendId() == Compute::CpuAcc )); // Load it into the runtime. It should pass. NetworkId netId; @@ -109,14 +109,14 @@ BOOST_AUTO_TEST_CASE(ClImportEnabledFallbackToNeon) size_t space = totalBytes + alignment + alignment; auto inputData0 = std::make_unique(space); void* alignedInputPtr0 = inputData0.get(); - BOOST_CHECK(std::align(alignment, totalBytes, alignedInputPtr0, space)); + CHECK(std::align(alignment, totalBytes, alignedInputPtr0, space)); auto* intputPtr0 = reinterpret_cast(alignedInputPtr0); std::copy(inputValue0.begin(), inputValue0.end(), intputPtr0); auto inputData1 = std::make_unique(space); void* alignedInputPtr1 = inputData1.get(); - BOOST_CHECK(std::align(alignment, totalBytes, alignedInputPtr1, space)); + CHECK(std::align(alignment, totalBytes, alignedInputPtr1, space)); auto* intputPtr1 = reinterpret_cast(alignedInputPtr1); std::copy(inputValue1.begin(), inputValue1.end(), intputPtr1); @@ -145,19 +145,19 @@ BOOST_AUTO_TEST_CASE(ClImportEnabledFallbackToNeon) // Executed Subtraction using CpuAcc std::size_t found = dump.find("NeonSubtractionWorkload_Execute"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Contain CopyMemGeneric found = dump.find("CopyMemGeneric"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Check output is as expected - BOOST_TEST(outputData == expectedOutput); + CHECK(outputData == expectedOutput); runtime->UnloadNetwork(netId); } -BOOST_AUTO_TEST_CASE(ClImportDisabledFallbackToNeon) +TEST_CASE("ClImportDisabledFallbackToNeon") { using namespace armnn; @@ -207,18 +207,18 @@ BOOST_AUTO_TEST_CASE(ClImportDisabledFallbackToNeon) armnn::Layer* const layer6 = GetFirstLayerWithName(graph, "output"); // Checks order is valid. - BOOST_TEST(CheckOrder(graph, layer0, layer1)); - BOOST_TEST(CheckOrder(graph, layer1, layer2)); - BOOST_TEST(CheckOrder(graph, layer2, layer3)); - BOOST_TEST(CheckOrder(graph, layer3, layer4)); - BOOST_TEST(CheckOrder(graph, layer4, layer5)); - BOOST_TEST(CheckOrder(graph, layer5, layer6)); + CHECK(CheckOrder(graph, layer0, layer1)); + CHECK(CheckOrder(graph, layer1, layer2)); + CHECK(CheckOrder(graph, layer2, layer3)); + CHECK(CheckOrder(graph, layer3, layer4)); + CHECK(CheckOrder(graph, layer4, layer5)); + CHECK(CheckOrder(graph, layer5, layer6)); // Use memory import between backends - BOOST_TEST((layer4->GetType() == LayerType::MemCopy)); + CHECK((layer4->GetType() == LayerType::MemCopy)); // Correctly use backend hint - BOOST_TEST((layer5->GetBackendId() == Compute::CpuAcc )); + CHECK((layer5->GetBackendId() == Compute::CpuAcc )); // Load it into the runtime. It should pass. NetworkId netId; @@ -269,17 +269,17 @@ BOOST_AUTO_TEST_CASE(ClImportDisabledFallbackToNeon) // Executed Subtraction using CpuAcc std::size_t found = dump.find("NeonSubtractionWorkload_Execute"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Contain CopyMemGeneric found = dump.find("CopyMemGeneric"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Check output is as expected - BOOST_TEST(outputData == expectedOutput); + CHECK(outputData == expectedOutput); } -BOOST_AUTO_TEST_CASE(ClImportEnabledFallbackSubgraphToNeon) +TEST_CASE("ClImportEnabledFallbackSubgraphToNeon") { using namespace armnn; @@ -342,21 +342,21 @@ BOOST_AUTO_TEST_CASE(ClImportEnabledFallbackSubgraphToNeon) armnn::Layer* const layer8 = GetFirstLayerWithName(graph, "output"); // Checks order is valid. - BOOST_TEST(CheckOrder(graph, layer0, layer1)); - BOOST_TEST(CheckOrder(graph, layer1, layer2)); - BOOST_TEST(CheckOrder(graph, layer2, layer3)); - BOOST_TEST(CheckOrder(graph, layer3, layer4)); - BOOST_TEST(CheckOrder(graph, layer4, layer5)); - BOOST_TEST(CheckOrder(graph, layer5, layer6)); - BOOST_TEST(CheckOrder(graph, layer6, layer7)); - BOOST_TEST(CheckOrder(graph, layer7, layer8)); + CHECK(CheckOrder(graph, layer0, layer1)); + CHECK(CheckOrder(graph, layer1, layer2)); + CHECK(CheckOrder(graph, layer2, layer3)); + CHECK(CheckOrder(graph, layer3, layer4)); + CHECK(CheckOrder(graph, layer4, layer5)); + CHECK(CheckOrder(graph, layer5, layer6)); + CHECK(CheckOrder(graph, layer6, layer7)); + CHECK(CheckOrder(graph, layer7, layer8)); // Use memory import between backends - BOOST_TEST((layer4->GetType() == LayerType::MemCopy)); - BOOST_TEST((layer6->GetType() == LayerType::MemCopy)); + CHECK((layer4->GetType() == LayerType::MemCopy)); + CHECK((layer6->GetType() == LayerType::MemCopy)); // Correctly use backend hint - BOOST_TEST((layer5->GetBackendId() == Compute::CpuAcc )); + CHECK((layer5->GetBackendId() == Compute::CpuAcc )); // Load it into the runtime. It should pass. NetworkId netId; @@ -388,14 +388,14 @@ BOOST_AUTO_TEST_CASE(ClImportEnabledFallbackSubgraphToNeon) size_t space = totalBytes + alignment + alignment; auto inputData0 = std::make_unique(space); void* alignedInputPtr0 = inputData0.get(); - BOOST_CHECK(std::align(alignment, totalBytes, alignedInputPtr0, space)); + CHECK(std::align(alignment, totalBytes, alignedInputPtr0, space)); auto* intputPtr0 = reinterpret_cast(alignedInputPtr0); std::copy(inputValue0.begin(), inputValue0.end(), intputPtr0); auto inputData1 = std::make_unique(space); void* alignedInputPtr1 = inputData1.get(); - BOOST_CHECK(std::align(alignment, totalBytes, alignedInputPtr1, space)); + CHECK(std::align(alignment, totalBytes, alignedInputPtr1, space)); auto* intputPtr1 = reinterpret_cast(alignedInputPtr1); std::copy(inputValue1.begin(), inputValue1.end(), intputPtr1); @@ -424,23 +424,23 @@ BOOST_AUTO_TEST_CASE(ClImportEnabledFallbackSubgraphToNeon) // Executed Subtraction using CpuAcc std::size_t found = dump.find("NeonSubtractionWorkload_Execute"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Correctly switch back to GpuAcc found = dump.find("ClPooling2dWorkload_Execute"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Contain CopyMemGeneric found = dump.find("CopyMemGeneric"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Check output is as expected - BOOST_TEST(outputData == expectedOutput); + CHECK(outputData == expectedOutput); runtime->UnloadNetwork(netId); } -BOOST_AUTO_TEST_CASE(ClImportDisableFallbackSubgraphToNeon) +TEST_CASE("ClImportDisableFallbackSubgraphToNeon") { using namespace armnn; @@ -498,21 +498,21 @@ BOOST_AUTO_TEST_CASE(ClImportDisableFallbackSubgraphToNeon) armnn::Layer* const layer8 = GetFirstLayerWithName(graph, "output"); // Checks order is valid. - BOOST_TEST(CheckOrder(graph, layer0, layer1)); - BOOST_TEST(CheckOrder(graph, layer1, layer2)); - BOOST_TEST(CheckOrder(graph, layer2, layer3)); - BOOST_TEST(CheckOrder(graph, layer3, layer4)); - BOOST_TEST(CheckOrder(graph, layer4, layer5)); - BOOST_TEST(CheckOrder(graph, layer5, layer6)); - BOOST_TEST(CheckOrder(graph, layer6, layer7)); - BOOST_TEST(CheckOrder(graph, layer7, layer8)); + CHECK(CheckOrder(graph, layer0, layer1)); + CHECK(CheckOrder(graph, layer1, layer2)); + CHECK(CheckOrder(graph, layer2, layer3)); + CHECK(CheckOrder(graph, layer3, layer4)); + CHECK(CheckOrder(graph, layer4, layer5)); + CHECK(CheckOrder(graph, layer5, layer6)); + CHECK(CheckOrder(graph, layer6, layer7)); + CHECK(CheckOrder(graph, layer7, layer8)); // Use memory import between backends - BOOST_TEST((layer4->GetType() == LayerType::MemCopy)); - BOOST_TEST((layer6->GetType() == LayerType::MemCopy)); + CHECK((layer4->GetType() == LayerType::MemCopy)); + CHECK((layer6->GetType() == LayerType::MemCopy)); // Correctly use backend hint - BOOST_TEST((layer5->GetBackendId() == Compute::CpuAcc )); + CHECK((layer5->GetBackendId() == Compute::CpuAcc )); // Load it into the runtime. It should pass. NetworkId netId; @@ -560,18 +560,18 @@ BOOST_AUTO_TEST_CASE(ClImportDisableFallbackSubgraphToNeon) // Executed Subtraction using CpuAcc std::size_t found = dump.find("NeonSubtractionWorkload_Execute"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Correctly switch back to GpuAcc found = dump.find("ClPooling2dWorkload_Execute"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Contain CopyMemGeneric found = dump.find("CopyMemGeneric"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Check output is as expected - BOOST_TEST(outputData == expectedOutput); + CHECK(outputData == expectedOutput); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/ClImportTensorHandleFactoryTests.cpp b/src/backends/cl/test/ClImportTensorHandleFactoryTests.cpp index 0c6a9c6e7b..fee40fd257 100644 --- a/src/backends/cl/test/ClImportTensorHandleFactoryTests.cpp +++ b/src/backends/cl/test/ClImportTensorHandleFactoryTests.cpp @@ -3,14 +3,17 @@ // SPDX-License-Identifier: MIT // +#include + #include -#include +#include -BOOST_AUTO_TEST_SUITE(ClImportTensorHandleFactoryTests) +TEST_SUITE("ClImportTensorHandleFactoryTests") +{ using namespace armnn; -BOOST_AUTO_TEST_CASE(ImportTensorFactoryAskedToCreateManagedTensorThrowsException) +TEST_CASE("ImportTensorFactoryAskedToCreateManagedTensorThrowsException") { // Create the factory to import tensors. ClImportTensorHandleFactory factory(static_cast(MemorySource::Malloc), @@ -18,11 +21,11 @@ BOOST_AUTO_TEST_CASE(ImportTensorFactoryAskedToCreateManagedTensorThrowsExceptio TensorInfo tensorInfo; // This factory is designed to import the memory of tensors. Asking for a handle that requires // a memory manager should result in an exception. - BOOST_REQUIRE_THROW(factory.CreateTensorHandle(tensorInfo, true), InvalidArgumentException); - BOOST_REQUIRE_THROW(factory.CreateTensorHandle(tensorInfo, DataLayout::NCHW, true), InvalidArgumentException); + REQUIRE_THROWS_AS(factory.CreateTensorHandle(tensorInfo, true), InvalidArgumentException); + REQUIRE_THROWS_AS(factory.CreateTensorHandle(tensorInfo, DataLayout::NCHW, true), InvalidArgumentException); } -BOOST_AUTO_TEST_CASE(ImportTensorFactoryCreateMallocTensorHandle) +TEST_CASE("ImportTensorFactoryCreateMallocTensorHandle") { // Create the factory to import tensors. ClImportTensorHandleFactory factory(static_cast(MemorySource::Malloc), @@ -32,24 +35,24 @@ BOOST_AUTO_TEST_CASE(ImportTensorFactoryCreateMallocTensorHandle) // Start with the TensorInfo factory method. Create an import tensor handle and verify the data is // passed through correctly. auto tensorHandle = factory.CreateTensorHandle(tensorInfo); - BOOST_ASSERT(tensorHandle); - BOOST_ASSERT(tensorHandle->GetImportFlags() == static_cast(MemorySource::Malloc)); - BOOST_ASSERT(tensorHandle->GetShape() == tensorShape); + ARMNN_ASSERT(tensorHandle); + ARMNN_ASSERT(tensorHandle->GetImportFlags() == static_cast(MemorySource::Malloc)); + ARMNN_ASSERT(tensorHandle->GetShape() == tensorShape); // Same method but explicitly specifying isManaged = false. tensorHandle = factory.CreateTensorHandle(tensorInfo, false); - BOOST_CHECK(tensorHandle); - BOOST_ASSERT(tensorHandle->GetImportFlags() == static_cast(MemorySource::Malloc)); - BOOST_ASSERT(tensorHandle->GetShape() == tensorShape); + CHECK(tensorHandle); + ARMNN_ASSERT(tensorHandle->GetImportFlags() == static_cast(MemorySource::Malloc)); + ARMNN_ASSERT(tensorHandle->GetShape() == tensorShape); // Now try TensorInfo and DataLayout factory method. tensorHandle = factory.CreateTensorHandle(tensorInfo, DataLayout::NHWC); - BOOST_CHECK(tensorHandle); - BOOST_ASSERT(tensorHandle->GetImportFlags() == static_cast(MemorySource::Malloc)); - BOOST_ASSERT(tensorHandle->GetShape() == tensorShape); + CHECK(tensorHandle); + ARMNN_ASSERT(tensorHandle->GetImportFlags() == static_cast(MemorySource::Malloc)); + ARMNN_ASSERT(tensorHandle->GetShape() == tensorShape); } -BOOST_AUTO_TEST_CASE(CreateSubtensorOfImportTensor) +TEST_CASE("CreateSubtensorOfImportTensor") { // Create the factory to import tensors. ClImportTensorHandleFactory factory(static_cast(MemorySource::Malloc), @@ -63,12 +66,12 @@ BOOST_AUTO_TEST_CASE(CreateSubtensorOfImportTensor) // Starting at an offset of 1x1. uint32_t origin[4] = { 1, 1, 0, 0 }; auto subTensor = factory.CreateSubTensorHandle(*tensorHandle, subTensorShape, origin); - BOOST_CHECK(subTensor); - BOOST_ASSERT(subTensor->GetShape() == subTensorShape); - BOOST_ASSERT(subTensor->GetParent() == tensorHandle.get()); + CHECK(subTensor); + ARMNN_ASSERT(subTensor->GetShape() == subTensorShape); + ARMNN_ASSERT(subTensor->GetParent() == tensorHandle.get()); } -BOOST_AUTO_TEST_CASE(CreateSubtensorNonZeroXYIsInvalid) +TEST_CASE("CreateSubtensorNonZeroXYIsInvalid") { // Create the factory to import tensors. ClImportTensorHandleFactory factory(static_cast(MemorySource::Malloc), @@ -84,10 +87,10 @@ BOOST_AUTO_TEST_CASE(CreateSubtensorNonZeroXYIsInvalid) uint32_t origin[4] = { 0, 0, 1, 1 }; auto subTensor = factory.CreateSubTensorHandle(*tensorHandle, subTensorShape, origin); // We expect a nullptr. - BOOST_ASSERT(subTensor == nullptr); + ARMNN_ASSERT(subTensor == nullptr); } -BOOST_AUTO_TEST_CASE(CreateSubtensorXYMustMatchParent) +TEST_CASE("CreateSubtensorXYMustMatchParent") { // Create the factory to import tensors. ClImportTensorHandleFactory factory(static_cast(MemorySource::Malloc), @@ -102,10 +105,10 @@ BOOST_AUTO_TEST_CASE(CreateSubtensorXYMustMatchParent) uint32_t origin[4] = { 1, 1, 0, 0 }; auto subTensor = factory.CreateSubTensorHandle(*tensorHandle, subTensorShape, origin); // We expect a nullptr. - BOOST_ASSERT(subTensor == nullptr); + ARMNN_ASSERT(subTensor == nullptr); } -BOOST_AUTO_TEST_CASE(CreateSubtensorMustBeSmallerThanParent) +TEST_CASE("CreateSubtensorMustBeSmallerThanParent") { // Create the factory to import tensors. ClImportTensorHandleFactory factory(static_cast(MemorySource::Malloc), @@ -119,7 +122,7 @@ BOOST_AUTO_TEST_CASE(CreateSubtensorMustBeSmallerThanParent) uint32_t origin[4] = { 1, 1, 0, 0 }; // This should result in a nullptr. auto subTensor = factory.CreateSubTensorHandle(*tensorHandle, subTensorShape, origin); - BOOST_ASSERT(subTensor == nullptr); + ARMNN_ASSERT(subTensor == nullptr); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/ClImportTensorHandleTests.cpp b/src/backends/cl/test/ClImportTensorHandleTests.cpp index 3c8bd678c4..931729a736 100644 --- a/src/backends/cl/test/ClImportTensorHandleTests.cpp +++ b/src/backends/cl/test/ClImportTensorHandleTests.cpp @@ -9,16 +9,17 @@ #include #include -#include +#include + #include #include using namespace armnn; -BOOST_AUTO_TEST_SUITE(ClImportTensorHandleTests) - -BOOST_FIXTURE_TEST_CASE(ClMallocImport, ClContextControlFixture) +TEST_SUITE("ClImportTensorHandleTests") +{ +TEST_CASE_FIXTURE(ClContextControlFixture, "ClMallocImport") { ClImportTensorHandleFactory handleFactory(static_cast(MemorySource::Malloc), static_cast(MemorySource::Malloc)); @@ -44,10 +45,10 @@ BOOST_FIXTURE_TEST_CASE(ClMallocImport, ClContextControlFixture) size_t space = totalBytes + alignment + alignment; auto testData = std::make_unique(space); void* alignedPtr = testData.get(); - BOOST_CHECK(std::align(alignment, totalBytes, alignedPtr, space)); + CHECK(std::align(alignment, totalBytes, alignedPtr, space)); // Import memory - BOOST_CHECK(handle->Import(alignedPtr, armnn::MemorySource::Malloc)); + CHECK(handle->Import(alignedPtr, armnn::MemorySource::Malloc)); // Input with negative values auto* typedPtr = reinterpret_cast(alignedPtr); @@ -60,11 +61,11 @@ BOOST_FIXTURE_TEST_CASE(ClMallocImport, ClContextControlFixture) // Validate result by checking that the output has no negative values for(unsigned int i = 0; i < numElements; ++i) { - BOOST_TEST(typedPtr[i] >= 0); + CHECK(typedPtr[i] >= 0); } } -BOOST_FIXTURE_TEST_CASE(ClIncorrectMemorySourceImport, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "ClIncorrectMemorySourceImport") { ClImportTensorHandleFactory handleFactory(static_cast(MemorySource::Malloc), static_cast(MemorySource::Malloc)); @@ -84,13 +85,13 @@ BOOST_FIXTURE_TEST_CASE(ClIncorrectMemorySourceImport, ClContextControlFixture) size_t space = totalBytes + alignment + alignment; auto testData = std::make_unique(space); void* alignedPtr = testData.get(); - BOOST_CHECK(std::align(alignment, totalBytes, alignedPtr, space)); + CHECK(std::align(alignment, totalBytes, alignedPtr, space)); // Import memory - BOOST_CHECK_THROW(handle->Import(alignedPtr, armnn::MemorySource::Undefined), MemoryImportException); + CHECK_THROWS_AS(handle->Import(alignedPtr, armnn::MemorySource::Undefined), MemoryImportException); } -BOOST_FIXTURE_TEST_CASE(ClInvalidMemorySourceImport, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "ClInvalidMemorySourceImport") { MemorySource invalidMemSource = static_cast(256); ClImportTensorHandleFactory handleFactory(static_cast(invalidMemSource), @@ -108,10 +109,10 @@ BOOST_FIXTURE_TEST_CASE(ClInvalidMemorySourceImport, ClContextControlFixture) }; // Import non-support memory - BOOST_CHECK_THROW(handle->Import(inputData.data(), invalidMemSource), MemoryImportException); + CHECK_THROWS_AS(handle->Import(inputData.data(), invalidMemSource), MemoryImportException); } -BOOST_FIXTURE_TEST_CASE(ClImportEndToEnd, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "ClImportEndToEnd") { // Create runtime in which test will run IRuntime::CreationOptions options; @@ -143,7 +144,7 @@ BOOST_FIXTURE_TEST_CASE(ClImportEndToEnd, ClContextControlFixture) optOptions.m_ImportEnabled = true; std::vector backends = {armnn::Compute::GpuAcc}; IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime->GetDeviceSpec(), optOptions); - BOOST_CHECK(optNet); + CHECK(optNet); // Loads it into the runtime. NetworkId netId; @@ -158,7 +159,7 @@ BOOST_FIXTURE_TEST_CASE(ClImportEndToEnd, ClContextControlFixture) size_t space = totalBytes + alignment + alignment; auto inputData = std::make_unique(space); void* alignedInputPtr = inputData.get(); - BOOST_CHECK(std::align(alignment, totalBytes, alignedInputPtr, space)); + CHECK(std::align(alignment, totalBytes, alignedInputPtr, space)); // Input with negative values auto* intputPtr = reinterpret_cast(alignedInputPtr); @@ -166,7 +167,7 @@ BOOST_FIXTURE_TEST_CASE(ClImportEndToEnd, ClContextControlFixture) auto outputData = std::make_unique(space); void* alignedOutputPtr = outputData.get(); - BOOST_CHECK(std::align(alignment, totalBytes, alignedOutputPtr, space)); + CHECK(std::align(alignment, totalBytes, alignedOutputPtr, space)); auto* outputPtr = reinterpret_cast(alignedOutputPtr); std::fill_n(outputPtr, numElements, -10.0f); @@ -192,26 +193,26 @@ BOOST_FIXTURE_TEST_CASE(ClImportEndToEnd, ClContextControlFixture) // Contains ActivationWorkload std::size_t found = dump.find("ActivationWorkload"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Contains SyncMemGeneric found = dump.find("SyncMemGeneric"); - BOOST_TEST(found != std::string::npos); + CHECK(found != std::string::npos); // Does not contain CopyMemGeneric found = dump.find("CopyMemGeneric"); - BOOST_TEST(found == std::string::npos); + CHECK(found == std::string::npos); runtime->UnloadNetwork(netId); // Check output is as expected // Validate result by checking that the output has no negative values auto* outputResult = reinterpret_cast(alignedOutputPtr); - BOOST_TEST(outputResult); + CHECK(outputResult); for(unsigned int i = 0; i < numElements; ++i) { - BOOST_TEST(outputResult[i] >= 0); + CHECK(outputResult[i] >= 0); } } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/ClJsonPrinterTests.cpp b/src/backends/cl/test/ClJsonPrinterTests.cpp index d188a8e9f4..2c24a53833 100644 --- a/src/backends/cl/test/ClJsonPrinterTests.cpp +++ b/src/backends/cl/test/ClJsonPrinterTests.cpp @@ -8,16 +8,13 @@ #include #include -#include +#include #include -BOOST_FIXTURE_TEST_SUITE(ClJsonPrinter, ClProfilingContextControlFixture) - -BOOST_AUTO_TEST_CASE(SoftmaxProfilerJsonPrinterGpuAccTest) +TEST_CASE_FIXTURE(ClProfilingContextControlFixture, "SoftmaxProfilerJsonPrinterGpuAccTest") { std::vector backends = {armnn::Compute::GpuAcc}; RunSoftmaxProfilerJsonPrinterTest(backends); -} -BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file +} \ No newline at end of file diff --git a/src/backends/cl/test/ClLayerSupportTests.cpp b/src/backends/cl/test/ClLayerSupportTests.cpp index 794a45fa48..b18da11176 100644 --- a/src/backends/cl/test/ClLayerSupportTests.cpp +++ b/src/backends/cl/test/ClLayerSupportTests.cpp @@ -16,176 +16,176 @@ #include #include -#include +#include #include -BOOST_AUTO_TEST_SUITE(ClLayerSupport) - -BOOST_FIXTURE_TEST_CASE(IsLayerSupportedFloat16Cl, ClContextControlFixture) +TEST_SUITE("ClLayerSupport") +{ +TEST_CASE_FIXTURE(ClContextControlFixture, "IsLayerSupportedFloat16Cl") { armnn::ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager()); IsLayerSupportedTests(&factory); } -BOOST_FIXTURE_TEST_CASE(IsLayerSupportedFloat32Cl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsLayerSupportedFloat32Cl") { armnn::ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager()); IsLayerSupportedTests(&factory); } -BOOST_FIXTURE_TEST_CASE(IsLayerSupportedQAsymmU8Cl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsLayerSupportedQAsymmU8Cl") { armnn::ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager()); IsLayerSupportedTests(&factory); } -BOOST_FIXTURE_TEST_CASE(IsLayerSupportedQAsymmS8Cl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsLayerSupportedQAsymmS8Cl") { armnn::ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager()); IsLayerSupportedTests(&factory); } -BOOST_FIXTURE_TEST_CASE(IsLayerSupportedQSymmS8Cl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsLayerSupportedQSymmS8Cl") { armnn::ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager()); IsLayerSupportedTests(&factory); } -BOOST_FIXTURE_TEST_CASE(IsConvertFp16ToFp32SupportedCl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsConvertFp16ToFp32SupportedCl") { std::string reasonIfUnsupported; bool result = IsConvertLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); } -BOOST_FIXTURE_TEST_CASE(IsConvertFp16ToFp32SupportedFp32InputCl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsConvertFp16ToFp32SupportedFp32InputCl") { std::string reasonIfUnsupported; bool result = IsConvertLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(!result); - BOOST_CHECK_EQUAL(reasonIfUnsupported, "Input should be Float16"); + CHECK(!result); + CHECK_EQ(reasonIfUnsupported, "Input should be Float16"); } -BOOST_FIXTURE_TEST_CASE(IsConvertFp16ToFp32SupportedFp16OutputCl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsConvertFp16ToFp32SupportedFp16OutputCl") { std::string reasonIfUnsupported; bool result = IsConvertLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(!result); - BOOST_CHECK_EQUAL(reasonIfUnsupported, "Output should be Float32"); + CHECK(!result); + CHECK_EQ(reasonIfUnsupported, "Output should be Float32"); } -BOOST_FIXTURE_TEST_CASE(IsConvertFp32ToFp16SupportedCl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsConvertFp32ToFp16SupportedCl") { std::string reasonIfUnsupported; bool result = IsConvertLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); } -BOOST_FIXTURE_TEST_CASE(IsConvertFp32ToFp16SupportedFp16InputCl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsConvertFp32ToFp16SupportedFp16InputCl") { std::string reasonIfUnsupported; bool result = IsConvertLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(!result); - BOOST_CHECK_EQUAL(reasonIfUnsupported, "Input should be Float32"); + CHECK(!result); + CHECK_EQ(reasonIfUnsupported, "Input should be Float32"); } -BOOST_FIXTURE_TEST_CASE(IsConvertFp32ToFp16SupportedFp32OutputCl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsConvertFp32ToFp16SupportedFp32OutputCl") { std::string reasonIfUnsupported; bool result = IsConvertLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(!result); - BOOST_CHECK_EQUAL(reasonIfUnsupported, "Output should be Float16"); + CHECK(!result); + CHECK_EQ(reasonIfUnsupported, "Output should be Float16"); } -BOOST_FIXTURE_TEST_CASE(IsLogicalBinarySupportedCl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsLogicalBinarySupportedCl") { std::string reasonIfUnsupported; bool result = IsLogicalBinaryLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); } -BOOST_FIXTURE_TEST_CASE(IsLogicalBinaryBroadcastSupportedCl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsLogicalBinaryBroadcastSupportedCl") { std::string reasonIfUnsupported; bool result = IsLogicalBinaryLayerBroadcastSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); } -BOOST_FIXTURE_TEST_CASE(IsMeanSupportedCl, ClContextControlFixture) +TEST_CASE_FIXTURE(ClContextControlFixture, "IsMeanSupportedCl") { std::string reasonIfUnsupported; bool result = IsMeanLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); } -BOOST_AUTO_TEST_CASE(IsConstantSupportedCl) +TEST_CASE("IsConstantSupportedCl") { std::string reasonIfUnsupported; bool result = IsConstantLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); result = IsConstantLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); result = IsConstantLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); result = IsConstantLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(!result); + CHECK(!result); result = IsConstantLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); result = IsConstantLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); result = IsConstantLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(result); + CHECK(result); result = IsConstantLayerSupportedTests(reasonIfUnsupported); - BOOST_CHECK(!result); + CHECK(!result); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/ClLayerTests.cpp b/src/backends/cl/test/ClLayerTests.cpp index 918ef039a3..1c3c831810 100644 --- a/src/backends/cl/test/ClLayerTests.cpp +++ b/src/backends/cl/test/ClLayerTests.cpp @@ -19,12 +19,13 @@ #include #include -#include +#include #include #include -BOOST_FIXTURE_TEST_SUITE(Compute_ArmComputeCl, ClContextControlFixture) +TEST_SUITE("Compute_ArmComputeCl") +{ using namespace armnn; @@ -34,1267 +35,1870 @@ using FactoryType = ClWorkloadFactory; // UNIT tests // Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(ConstantLinearActivation, ConstantLinearActivationTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ConstantLinearActivation, ClContextControlFixture, ConstantLinearActivationTest) // Sigmoid Activation / Logistic -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleSigmoid, SimpleSigmoidTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleSigmoidUint8, SimpleSigmoidUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleSigmoid, ClContextControlFixture, SimpleSigmoidTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleSigmoidUint8, ClContextControlFixture, SimpleSigmoidUint8Test) // BoundedReLU Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(ReLu1, BoundedReLuUpperAndLowerBoundTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReLu6, BoundedReLuUpperBoundOnlyTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReLu1Uint8, BoundedReLuUint8UpperAndLowerBoundTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReLu6Uint8, BoundedReLuUint8UpperBoundOnlyTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReLu1, ClContextControlFixture, BoundedReLuUpperAndLowerBoundTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReLu6, ClContextControlFixture, BoundedReLuUpperBoundOnlyTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReLu1Uint8, ClContextControlFixture, BoundedReLuUint8UpperAndLowerBoundTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReLu6Uint8, ClContextControlFixture, BoundedReLuUint8UpperBoundOnlyTest) // ReLU Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(ReLu, ReLuTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReLuUint8, ReLuUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReLu, ClContextControlFixture, ReLuTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReLuUint8, ClContextControlFixture, ReLuUint8Test) // SoftReLU Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(SoftReLu, SoftReLuTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SoftReLu, ClContextControlFixture, SoftReLuTest) // LeakyReLU Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(LeakyReLu, LeakyReLuTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LeakyReLu, ClContextControlFixture, LeakyReLuTest) // Abs Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(Abs, AbsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Abs, ClContextControlFixture, AbsTest) // Sqrt Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(Sqrt, SqrtTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SqrtNN, SqrtNNTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Sqrt, ClContextControlFixture, SqrtTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SqrtNN, ClContextControlFixture, SqrtNNTest) // Square Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(Square, SquareTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Square, ClContextControlFixture, SquareTest) // Tanh Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(Tanh, TanhTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Tanh, ClContextControlFixture, TanhTest) // Elu Activation -ARMNN_AUTO_TEST_CASE_WITH_THF(Elu, EluTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Elu, ClContextControlFixture, EluTest) // Batch To Space -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcFloat321, BatchToSpaceNdNhwcTest1) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcFloat322, BatchToSpaceNdNhwcTest2) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcFloat323, BatchToSpaceNdNhwcTest3) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcFloat321, + ClContextControlFixture, + BatchToSpaceNdNhwcTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcFloat322, + ClContextControlFixture, + BatchToSpaceNdNhwcTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcFloat323, + ClContextControlFixture, + BatchToSpaceNdNhwcTest3) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwFloat321, + ClContextControlFixture, + BatchToSpaceNdNchwTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwFloat322, + ClContextControlFixture, + BatchToSpaceNdNchwTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwFloat323, + ClContextControlFixture, + BatchToSpaceNdNchwTest3) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcInt1, + ClContextControlFixture, + BatchToSpaceNdNhwcTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcInt2, + ClContextControlFixture, + BatchToSpaceNdNhwcTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcInt3, + ClContextControlFixture, + BatchToSpaceNdNhwcTest3) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwInt1, + ClContextControlFixture, + BatchToSpaceNdNchwTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwInt2, + ClContextControlFixture, + BatchToSpaceNdNchwTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwInt3, + ClContextControlFixture, + BatchToSpaceNdNchwTest3) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcUint1, + ClContextControlFixture, + BatchToSpaceNdNhwcTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcUint2, + ClContextControlFixture, + BatchToSpaceNdNhwcTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcUint3, + ClContextControlFixture, + BatchToSpaceNdNhwcTest3) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwUint1, + ClContextControlFixture, + BatchToSpaceNdNchwTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwUint2, + ClContextControlFixture, + BatchToSpaceNdNchwTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwUint3, + ClContextControlFixture, + BatchToSpaceNdNchwTest3) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwFloat321, BatchToSpaceNdNchwTest1) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwFloat322, BatchToSpaceNdNchwTest2) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwFloat323, BatchToSpaceNdNchwTest3) - -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcInt1, BatchToSpaceNdNhwcTest1) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcInt2, BatchToSpaceNdNhwcTest2) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcInt3, BatchToSpaceNdNhwcTest3) - -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwInt1, BatchToSpaceNdNchwTest1) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwInt2, BatchToSpaceNdNchwTest2) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwInt3, BatchToSpaceNdNchwTest3) +// Fully Connected +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFullyConnected, + ClContextControlFixture, + FullyConnectedFloat32Test, + false, + false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFullyConnectedWithBias, + ClContextControlFixture, + FullyConnectedFloat32Test, + true, + false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFullyConnectedWithTranspose, + ClContextControlFixture, + FullyConnectedFloat32Test, + false, + true) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(FullyConnectedUint8, + ClContextControlFixture, + FullyConnectedTest, + false, + true) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(FullyConnectedBiasedUint8, + ClContextControlFixture, + FullyConnectedTest, + true, + true) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(FullyConnectedLarge, + ClContextControlFixture, + FullyConnectedLargeTest, + false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(FullyConnectedLargeTransposed, + ClContextControlFixture, + FullyConnectedLargeTest, + true) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcUint1, BatchToSpaceNdNhwcTest1) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcUint2, BatchToSpaceNdNhwcTest2) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcUint3, BatchToSpaceNdNhwcTest3) +// Convolution +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution1d, + ClContextControlFixture, + Convolution1dTest, + true) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution2d, + ClContextControlFixture, + SimpleConvolution2d3x5Test, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution2dNhwc, + ClContextControlFixture, + SimpleConvolution2d3x5Test, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution2d3x3Uint8, + ClContextControlFixture, + SimpleConvolution2d3x3Uint8Test, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution2d3x3Uint8Nhwc, + ClContextControlFixture, + SimpleConvolution2d3x3Uint8Test, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedConvolution2d, + ClContextControlFixture, + SimpleConvolution2d3x5Test, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedConvolution2dNhwc, + ClContextControlFixture, + SimpleConvolution2d3x5Test, + false, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedConvolution2dStride2x2Nhwc, + ClContextControlFixture, + SimpleConvolution2d3x3Stride2x2Test, + false, + DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwUint1, BatchToSpaceNdNchwTest1) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwUint2, BatchToSpaceNdNchwTest2) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwUint3, BatchToSpaceNdNchwTest3) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedConvolution2dSquare, + ClContextControlFixture, + SimpleConvolution2d3x3Test, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution2dAsymmetricPadding, + ClContextControlFixture, + Convolution2dAsymmetricPaddingTest, + DataLayout::NCHW) -// Fully Connected -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFullyConnected, FullyConnectedFloat32Test, false, false) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFullyConnectedWithBias, FullyConnectedFloat32Test, true, false) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFullyConnectedWithTranspose, FullyConnectedFloat32Test, false, true) -ARMNN_AUTO_TEST_CASE_WITH_THF(FullyConnectedUint8, FullyConnectedTest, false, true) -ARMNN_AUTO_TEST_CASE_WITH_THF(FullyConnectedBiasedUint8, FullyConnectedTest, true, true) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedConvolution2dSquareNhwc, + ClContextControlFixture, + SimpleConvolution2d3x3Test, + false, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution2dAsymmetricPaddingNhwc, + ClContextControlFixture, + Convolution2dAsymmetricPaddingTest, + DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(FullyConnectedLarge, FullyConnectedLargeTest, false) -ARMNN_AUTO_TEST_CASE_WITH_THF(FullyConnectedLargeTransposed, FullyConnectedLargeTest, true) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution2dSquareNhwc, + ClContextControlFixture, + SimpleConvolution2d3x3NhwcTest, + false) -// Convolution -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution1d, Convolution1dTest, true) - -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution2d, SimpleConvolution2d3x5Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution2dNhwc, SimpleConvolution2d3x5Test, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution2d3x3Uint8, SimpleConvolution2d3x3Uint8Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution2d3x3Uint8Nhwc, SimpleConvolution2d3x3Uint8Test, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedConvolution2d, SimpleConvolution2d3x5Test, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedConvolution2dNhwc, SimpleConvolution2d3x5Test, false, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedConvolution2dStride2x2Nhwc, - SimpleConvolution2d3x3Stride2x2Test, false, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedConvolution2dSquare, SimpleConvolution2d3x3Test, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution2dAsymmetricPadding, - Convolution2dAsymmetricPaddingTest, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedConvolution2dSquareNhwc, SimpleConvolution2d3x3Test, false, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution2dAsymmetricPaddingNhwc, - Convolution2dAsymmetricPaddingTest, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution2dSquareNhwc, SimpleConvolution2d3x3NhwcTest, false) - -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d3x3Dilation3x3, - Convolution2d3x3Dilation3x3Test, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d3x3Dilation3x3Nhwc, - Convolution2d3x3Dilation3x3Test, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d3x3Dilation3x3Uint8, - Convolution2d3x3Dilation3x3Test, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d3x3Dilation3x3NhwcUint8, - Convolution2d3x3Dilation3x3Test, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x3x3Dilation3x3, - Convolution2d2x3x3Dilation3x3Test, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x3x3Dilation3x3Nhwc, - Convolution2d2x3x3Dilation3x3Test, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x3x3Dilation3x3Uint8, - Convolution2d2x3x3Dilation3x3Test, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x3x3Dilation3x3NhwcUint8, - Convolution2d2x3x3Dilation3x3Test, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Nhwc, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test, - false, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Uint8, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3NhwcUint8, - Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test, - false, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2dPerAxisQuantTestNchw, Convolution2dPerAxisQuantTest, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2dPerAxisQuantTestNhwc, Convolution2dPerAxisQuantTest, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d3x3Dilation3x3, + ClContextControlFixture, + Convolution2d3x3Dilation3x3Test, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d3x3Dilation3x3Nhwc, + ClContextControlFixture, + Convolution2d3x3Dilation3x3Test, + false, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d3x3Dilation3x3Uint8, + ClContextControlFixture, + Convolution2d3x3Dilation3x3Test, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d3x3Dilation3x3NhwcUint8, + ClContextControlFixture, + Convolution2d3x3Dilation3x3Test, + false, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x3x3Dilation3x3, + ClContextControlFixture, + Convolution2d2x3x3Dilation3x3Test, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x3x3Dilation3x3Nhwc, + ClContextControlFixture, + Convolution2d2x3x3Dilation3x3Test, + false, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x3x3Dilation3x3Uint8, + ClContextControlFixture, + Convolution2d2x3x3Dilation3x3Test, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x3x3Dilation3x3NhwcUint8, + ClContextControlFixture, + Convolution2d2x3x3Dilation3x3Test, + false, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3, + ClContextControlFixture, + Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Nhwc, + ClContextControlFixture, + Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test, + false, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Uint8, + ClContextControlFixture, + Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3NhwcUint8, + ClContextControlFixture, + Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test, + false, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2dPerAxisQuantTestNchw, + ClContextControlFixture, + Convolution2dPerAxisQuantTest, + DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2dPerAxisQuantTestNhwc, + ClContextControlFixture, + Convolution2dPerAxisQuantTest, + DataLayout::NHWC); // Depthwise Convolution -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dDepthMul1, - DepthwiseConvolution2dDepthMul1Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedDepthwiseConvolution2dDepthMul1, - DepthwiseConvolution2dDepthMul1Test, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dDepthMul1Uint8, - DepthwiseConvolution2dDepthMul1Uint8Test, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedDepthwiseConvolution2dDepthMul1Uint8, - DepthwiseConvolution2dDepthMul1Uint8Test, false, DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dDepthMul1, + ClContextControlFixture, + DepthwiseConvolution2dDepthMul1Test, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedDepthwiseConvolution2dDepthMul1, + ClContextControlFixture, + DepthwiseConvolution2dDepthMul1Test, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dDepthMul1Uint8, + ClContextControlFixture, + DepthwiseConvolution2dDepthMul1Uint8Test, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedDepthwiseConvolution2dDepthMul1Uint8, + ClContextControlFixture, + DepthwiseConvolution2dDepthMul1Uint8Test, + false, + DataLayout::NCHW) // NHWC Depthwise Convolution -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dDepthMul1Nhwc, - DepthwiseConvolution2dDepthMul1Test, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedDepthwiseConvolution2dDepthMul1Nhwc, - DepthwiseConvolution2dDepthMul1Test, false, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dDepthMul1Uint8Nhwc, - DepthwiseConvolution2dDepthMul1Uint8Test, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedDepthwiseConvolution2dDepthMul1Uint8Nhwc, - DepthwiseConvolution2dDepthMul1Uint8Test, false, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleDepthwiseConvolution2d3x3Dilation3x3Nhwc, - SimpleDepthwiseConvolution2d3x3Dilation3x3NhwcTest) - - -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dDepthNhwc, DepthwiseConvolution2dDepthNhwcTest, false) - -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dAsymmetric, - DepthwiseConvolution2dAsymmetricTest, true, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedDepthwiseConvolution2dAsymmetric, - DepthwiseConvolution2dAsymmetricTest, false, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dAsymmetricNhwc, - DepthwiseConvolution2dAsymmetricTest, true, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedDepthwiseConvolution2dAsymmetricNhwc, - DepthwiseConvolution2dAsymmetricTest, false, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dDepthMul64, DepthwiseConvolution2dDepthMul64Test); - -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dPerAxisQuantTestNchw, DepthwiseConvolution2dPerAxisQuantTest, - DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE_WITH_THF(DepthwiseConvolution2dPerAxisQuantTestNhwc, DepthwiseConvolution2dPerAxisQuantTest, - DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dDepthMul1Nhwc, + ClContextControlFixture, + DepthwiseConvolution2dDepthMul1Test, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedDepthwiseConvolution2dDepthMul1Nhwc, + ClContextControlFixture, + DepthwiseConvolution2dDepthMul1Test, + false, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dDepthMul1Uint8Nhwc, + ClContextControlFixture, + DepthwiseConvolution2dDepthMul1Uint8Test, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedDepthwiseConvolution2dDepthMul1Uint8Nhwc, + ClContextControlFixture, + DepthwiseConvolution2dDepthMul1Uint8Test, + false, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleDepthwiseConvolution2d3x3Dilation3x3Nhwc, + ClContextControlFixture, + SimpleDepthwiseConvolution2d3x3Dilation3x3NhwcTest) + + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dDepthNhwc, + ClContextControlFixture, + DepthwiseConvolution2dDepthNhwcTest, + false) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dAsymmetric, + ClContextControlFixture, + DepthwiseConvolution2dAsymmetricTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedDepthwiseConvolution2dAsymmetric, + ClContextControlFixture, + DepthwiseConvolution2dAsymmetricTest, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dAsymmetricNhwc, + ClContextControlFixture, + DepthwiseConvolution2dAsymmetricTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedDepthwiseConvolution2dAsymmetricNhwc, + ClContextControlFixture, + DepthwiseConvolution2dAsymmetricTest, + false, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dDepthMul64, + ClContextControlFixture, + DepthwiseConvolution2dDepthMul64Test); + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dPerAxisQuantTestNchw, + ClContextControlFixture, + DepthwiseConvolution2dPerAxisQuantTest, + DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dPerAxisQuantTestNhwc, + ClContextControlFixture, + DepthwiseConvolution2dPerAxisQuantTest, + DataLayout::NHWC); // Splitter -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleSplitterFloat32, SplitterFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleSplitterUint8, SplitterUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleSplitterFloat32, ClContextControlFixture, SplitterFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleSplitterUint8, ClContextControlFixture, SplitterUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(CopyViaSplitterFloat32, CopyViaSplitterFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(CopyViaSplitterUint8, CopyViaSplitterUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(CopyViaSplitterFloat32, ClContextControlFixture, CopyViaSplitterFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(CopyViaSplitterUint8, ClContextControlFixture, CopyViaSplitterUint8Test) // Concat -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConcat, ConcatTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ConcatUint8, ConcatUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(ConcatUint8DifferentInputOutputQParam, - ConcatDifferentInputOutputQParamTest, false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConcat, ClContextControlFixture, ConcatTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ConcatUint8, ClContextControlFixture, ConcatUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ConcatUint8DifferentInputOutputQParam, + ClContextControlFixture, + ConcatDifferentInputOutputQParamTest, + false) // Normalization -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleNormalizationAcross, SimpleNormalizationAcrossTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleNormalizationWithin, SimpleNormalizationWithinTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleNormalizationAcrossNhwc, SimpleNormalizationAcrossNhwcTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(AcrossChannelNormalization, AcrossChannelNormalizationTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleNormalizationAcross, ClContextControlFixture, SimpleNormalizationAcrossTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleNormalizationWithin, ClContextControlFixture, SimpleNormalizationWithinTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleNormalizationAcrossNhwc, + ClContextControlFixture, + SimpleNormalizationAcrossNhwcTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AcrossChannelNormalization, + ClContextControlFixture, + AcrossChannelNormalizationTest) // Pooling -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling2dSize3x3Stride2x4, SimpleMaxPooling2dSize3x3Stride2x4Test, true) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling2dSize3x3Stride2x4Uint8, - SimpleMaxPooling2dSize3x3Stride2x4Uint8Test, true) - -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleMaxPooling2d, IgnorePaddingSimpleMaxPooling2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleMaxPooling2dUint8, IgnorePaddingSimpleMaxPooling2dUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingMaxPooling2dSize3, IgnorePaddingMaxPooling2dSize3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingMaxPooling2dSize3Uint8, IgnorePaddingMaxPooling2dSize3Uint8Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleAveragePooling2d, IgnorePaddingSimpleAveragePooling2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleAveragePooling2dUint8, IgnorePaddingSimpleAveragePooling2dUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleAveragePooling2dNoPadding, - IgnorePaddingSimpleAveragePooling2dNoPaddingTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleAveragePooling2dNoPaddingUint8, - IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingAveragePooling2dSize3, IgnorePaddingAveragePooling2dSize3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingAveragePooling2dSize3Uint8, IgnorePaddingAveragePooling2dSize3Uint8Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingSimpleL2Pooling2d, IgnorePaddingSimpleL2Pooling2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_IgnorePaddingSimpleL2Pooling2dUint8, IgnorePaddingSimpleL2Pooling2dUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingL2Pooling2dSize3, IgnorePaddingL2Pooling2dSize3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_IgnorePaddingL2Pooling2dSize3Uint8, IgnorePaddingL2Pooling2dSize3Uint8Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling2d, SimpleMaxPooling2dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling2dNhwc, SimpleMaxPooling2dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling2dUint8, SimpleMaxPooling2dUint8Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMaxPooling2dUint8Nhwc, SimpleMaxPooling2dUint8Test, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAveragePooling2d, SimpleAveragePooling2dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAveragePooling2dNhwc, SimpleAveragePooling2dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAveragePooling2dUint8, SimpleAveragePooling2dUint8Test, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAveragePooling2dUint8Nhwc, SimpleAveragePooling2dUint8Test, DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingAveragePooling2dSize3x2Stride2x2, - IgnorePaddingAveragePooling2dSize3x2Stride2x2Test, - false) -ARMNN_AUTO_TEST_CASE_WITH_THF(IgnorePaddingAveragePooling2dSize3x2Stride2x2NoPadding, - IgnorePaddingAveragePooling2dSize3x2Stride2x2Test, - true) -ARMNN_AUTO_TEST_CASE_WITH_THF(LargeTensorsAveragePooling2d, LargeTensorsAveragePooling2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LargeTensorsAveragePooling2dUint8, LargeTensorsAveragePooling2dUint8Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleL2Pooling2d, SimpleL2Pooling2dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleL2Pooling2dNhwc, SimpleL2Pooling2dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_SimpleL2Pooling2dUint8, SimpleL2Pooling2dUint8Test, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Pooling2dSize3Stride1, L2Pooling2dSize3Stride1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_L2Pooling2dSize3Stride1Uint8, L2Pooling2dSize3Stride1Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Pooling2dSize3Stride3, L2Pooling2dSize3Stride3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_L2Pooling2dSize3Stride3Uint8, L2Pooling2dSize3Stride3Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Pooling2dSize3Stride4, L2Pooling2dSize3Stride4Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_L2Pooling2dSize3Stride4Uint8, L2Pooling2dSize3Stride4Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Pooling2dSize7, L2Pooling2dSize7Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_L2Pooling2dSize7Uint8, L2Pooling2dSize7Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Pooling2dSize9, L2Pooling2dSize9Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(UNSUPPORTED_L2Pooling2dSize9Uint8, L2Pooling2dSize9Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling2dSize3x3Stride2x4, + ClContextControlFixture, + SimpleMaxPooling2dSize3x3Stride2x4Test, + true) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling2dSize3x3Stride2x4Uint8, + ClContextControlFixture, + SimpleMaxPooling2dSize3x3Stride2x4Uint8Test, + true) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleMaxPooling2d, + ClContextControlFixture, + IgnorePaddingSimpleMaxPooling2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleMaxPooling2dUint8, + ClContextControlFixture, + IgnorePaddingSimpleMaxPooling2dUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingMaxPooling2dSize3, + ClContextControlFixture, + IgnorePaddingMaxPooling2dSize3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingMaxPooling2dSize3Uint8, + ClContextControlFixture, + IgnorePaddingMaxPooling2dSize3Uint8Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleAveragePooling2d, + ClContextControlFixture, + IgnorePaddingSimpleAveragePooling2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleAveragePooling2dUint8, + ClContextControlFixture, + IgnorePaddingSimpleAveragePooling2dUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleAveragePooling2dNoPadding, + ClContextControlFixture, + IgnorePaddingSimpleAveragePooling2dNoPaddingTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleAveragePooling2dNoPaddingUint8, + ClContextControlFixture, + IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingAveragePooling2dSize3, + ClContextControlFixture, + IgnorePaddingAveragePooling2dSize3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingAveragePooling2dSize3Uint8, + ClContextControlFixture, + IgnorePaddingAveragePooling2dSize3Uint8Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingSimpleL2Pooling2d, + ClContextControlFixture, + IgnorePaddingSimpleL2Pooling2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_IgnorePaddingSimpleL2Pooling2dUint8, + ClContextControlFixture, + IgnorePaddingSimpleL2Pooling2dUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingL2Pooling2dSize3, + ClContextControlFixture, + IgnorePaddingL2Pooling2dSize3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_IgnorePaddingL2Pooling2dSize3Uint8, + ClContextControlFixture, + IgnorePaddingL2Pooling2dSize3Uint8Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling2d, + ClContextControlFixture, + SimpleMaxPooling2dTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling2dNhwc, + ClContextControlFixture, + SimpleMaxPooling2dTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling2dUint8, + ClContextControlFixture, + SimpleMaxPooling2dUint8Test, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling2dUint8Nhwc, + ClContextControlFixture, + SimpleMaxPooling2dUint8Test, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAveragePooling2d, + ClContextControlFixture, + SimpleAveragePooling2dTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAveragePooling2dNhwc, + ClContextControlFixture, + SimpleAveragePooling2dTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAveragePooling2dUint8, + ClContextControlFixture, + SimpleAveragePooling2dUint8Test, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAveragePooling2dUint8Nhwc, + ClContextControlFixture, + SimpleAveragePooling2dUint8Test, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingAveragePooling2dSize3x2Stride2x2, + ClContextControlFixture, + IgnorePaddingAveragePooling2dSize3x2Stride2x2Test, + false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(IgnorePaddingAveragePooling2dSize3x2Stride2x2NoPadding, + ClContextControlFixture, + IgnorePaddingAveragePooling2dSize3x2Stride2x2Test, + true) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LargeTensorsAveragePooling2d, + ClContextControlFixture, + LargeTensorsAveragePooling2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LargeTensorsAveragePooling2dUint8, + ClContextControlFixture, + LargeTensorsAveragePooling2dUint8Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleL2Pooling2d, + ClContextControlFixture, + SimpleL2Pooling2dTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleL2Pooling2dNhwc, + ClContextControlFixture, + SimpleL2Pooling2dTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_SimpleL2Pooling2dUint8, + ClContextControlFixture, + SimpleL2Pooling2dUint8Test, + DataLayout::NCHW) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Pooling2dSize3Stride1, ClContextControlFixture, L2Pooling2dSize3Stride1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_L2Pooling2dSize3Stride1Uint8, + ClContextControlFixture, + L2Pooling2dSize3Stride1Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Pooling2dSize3Stride3, + ClContextControlFixture, + L2Pooling2dSize3Stride3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_L2Pooling2dSize3Stride3Uint8, + ClContextControlFixture, + L2Pooling2dSize3Stride3Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Pooling2dSize3Stride4, + ClContextControlFixture, + L2Pooling2dSize3Stride4Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_L2Pooling2dSize3Stride4Uint8, + ClContextControlFixture, + L2Pooling2dSize3Stride4Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Pooling2dSize7, + ClContextControlFixture, + L2Pooling2dSize7Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_L2Pooling2dSize7Uint8, + ClContextControlFixture, + L2Pooling2dSize7Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Pooling2dSize9, ClContextControlFixture, L2Pooling2dSize9Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UNSUPPORTED_L2Pooling2dSize9Uint8, ClContextControlFixture, L2Pooling2dSize9Uint8Test) // Add -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleAdd, AdditionTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Add5d, Addition5dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(AddBroadcast1Element, AdditionBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(AddBroadcast, AdditionBroadcastTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleAdd, ClContextControlFixture, AdditionTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Add5d, ClContextControlFixture, Addition5dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AddBroadcast1Element, ClContextControlFixture, AdditionBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AddBroadcast, ClContextControlFixture, AdditionBroadcastTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(AdditionUint8, AdditionUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(AddBroadcastUint8, AdditionBroadcastUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(AddBroadcast1ElementUint8, AdditionBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AdditionUint8, ClContextControlFixture, AdditionUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AddBroadcastUint8, ClContextControlFixture, AdditionBroadcastUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AddBroadcast1ElementUint8, + ClContextControlFixture, + AdditionBroadcast1ElementUint8Test) // Sub -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleSub, SubtractionTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SubBroadcast1Element, SubtractionBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SubBroadcast, SubtractionBroadcastTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleSub, ClContextControlFixture, SubtractionTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SubBroadcast1Element, ClContextControlFixture, SubtractionBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SubBroadcast, ClContextControlFixture, SubtractionBroadcastTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SubtractionUint8, SubtractionUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SubBroadcastUint8, SubtractionBroadcastUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SubBroadcast1ElementUint8, SubtractionBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SubtractionUint8, ClContextControlFixture, SubtractionUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SubBroadcastUint8, ClContextControlFixture, SubtractionBroadcastUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SubBroadcast1ElementUint8, + ClContextControlFixture, + SubtractionBroadcast1ElementUint8Test) // Div -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleDivision, DivisionTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(DivisionByZero, DivisionByZeroTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(DivisionBroadcast1Element, DivisionBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(DivisionBroadcast1DVector, DivisionBroadcast1DVectorTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleDivision, ClContextControlFixture, DivisionTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DivisionByZero, ClContextControlFixture, DivisionByZeroTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DivisionBroadcast1Element, ClContextControlFixture, DivisionBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DivisionBroadcast1DVector, ClContextControlFixture, DivisionBroadcast1DVectorTest) // NOTE: quantized division is not supported by CL and not required by the // android NN api // Mul -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleMultiplication, MultiplicationTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MultiplicationBroadcast1Element, MultiplicationBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MultiplicationBroadcast1DVector, MultiplicationBroadcast1DVectorTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MultiplicationUint8, MultiplicationUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MultiplicationBroadcast1ElementUint8, MultiplicationBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MultiplicationBroadcast1DVectorUint8, MultiplicationBroadcast1DVectorUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Multiplication5d, Multiplication5dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMultiplication, ClContextControlFixture, MultiplicationTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiplicationBroadcast1Element, + ClContextControlFixture, + MultiplicationBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiplicationBroadcast1DVector, + ClContextControlFixture, + MultiplicationBroadcast1DVectorTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiplicationUint8, ClContextControlFixture, MultiplicationUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiplicationBroadcast1ElementUint8, + ClContextControlFixture, + MultiplicationBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiplicationBroadcast1DVectorUint8, + ClContextControlFixture, + MultiplicationBroadcast1DVectorUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Multiplication5d, ClContextControlFixture, Multiplication5dTest) // Batch Norm -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchNormFloat32, BatchNormFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(BatchNormFloat32Nhwc, BatchNormFloat32NhwcTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchNormFloat32, ClContextControlFixture, BatchNormFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchNormFloat32Nhwc, ClContextControlFixture, BatchNormFloat32NhwcTest) // Rank -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1Float16, RankDimSize1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1Float32, RankDimSize1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QAsymmU8, RankDimSize1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1Signed32, RankDimSize1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QSymmS16, RankDimSize1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QAsymmS8, RankDimSize1Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2Float16, RankDimSize2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2Float32, RankDimSize2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QAsymmU8, RankDimSize2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2Signed32, RankDimSize2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QSymmS16, RankDimSize2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QAsymmS8, RankDimSize2Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3Float16, RankDimSize3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3Float32, RankDimSize3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QAsymmU8, RankDimSize3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3Signed32, RankDimSize3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QSymmS16, RankDimSize3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QAsymmS8, RankDimSize3Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4Float16, RankDimSize4Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4Float32, RankDimSize4Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QAsymmU8, RankDimSize4Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4Signed32, RankDimSize4Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QSymmS16, RankDimSize4Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QAsymmS8, RankDimSize4Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1Float16, ClContextControlFixture, RankDimSize1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1Float32, ClContextControlFixture, RankDimSize1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1QAsymmU8, ClContextControlFixture, RankDimSize1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1Signed32, ClContextControlFixture, RankDimSize1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1QSymmS16, ClContextControlFixture, RankDimSize1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1QAsymmS8, ClContextControlFixture, RankDimSize1Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2Float16, ClContextControlFixture, RankDimSize2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2Float32, ClContextControlFixture, RankDimSize2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2QAsymmU8, ClContextControlFixture, RankDimSize2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2Signed32, ClContextControlFixture, RankDimSize2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2QSymmS16, ClContextControlFixture, RankDimSize2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2QAsymmS8, ClContextControlFixture, RankDimSize2Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3Float16, ClContextControlFixture, RankDimSize3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3Float32, ClContextControlFixture, RankDimSize3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3QAsymmU8, ClContextControlFixture, RankDimSize3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3Signed32, ClContextControlFixture, RankDimSize3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3QSymmS16, ClContextControlFixture, RankDimSize3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3QAsymmS8, ClContextControlFixture, RankDimSize3Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4Float16, ClContextControlFixture, RankDimSize4Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4Float32, ClContextControlFixture, RankDimSize4Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4QAsymmU8, ClContextControlFixture, RankDimSize4Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4Signed32, ClContextControlFixture, RankDimSize4Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4QSymmS16, ClContextControlFixture, RankDimSize4Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4QAsymmS8, ClContextControlFixture, RankDimSize4Test) // InstanceNormalization -ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat32Nchw, InstanceNormFloat32Test, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat16Nchw, InstanceNormFloat16Test, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat32Nhwc, InstanceNormFloat32Test, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat16Nhwc, InstanceNormFloat16Test, DataLayout::NHWC); - -ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat32Nchw2, InstanceNormFloat32Test2, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat16Nchw2, InstanceNormFloat16Test2, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat32Nhwc2, InstanceNormFloat32Test2, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat16Nhwc2, InstanceNormFloat16Test2, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(InstanceNormFloat32Nchw, + ClContextControlFixture, + InstanceNormFloat32Test, + DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(InstanceNormFloat16Nchw, + ClContextControlFixture, + InstanceNormFloat16Test, + DataLayout::NCHW); + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(InstanceNormFloat32Nhwc, + ClContextControlFixture, + InstanceNormFloat32Test, + DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(InstanceNormFloat16Nhwc, + ClContextControlFixture, + InstanceNormFloat16Test, + DataLayout::NHWC); + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(InstanceNormFloat32Nchw2, + ClContextControlFixture, + InstanceNormFloat32Test2, + DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(InstanceNormFloat16Nchw2, + ClContextControlFixture, + InstanceNormFloat16Test2, + DataLayout::NCHW); + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(InstanceNormFloat32Nhwc2, + ClContextControlFixture, + InstanceNormFloat32Test2, + DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(InstanceNormFloat16Nhwc2, + ClContextControlFixture, + InstanceNormFloat16Test2, + DataLayout::NHWC); // L2 Normalization -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Normalization1d, L2Normalization1dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Normalization2d, L2Normalization2dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Normalization3d, L2Normalization3dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Normalization4d, L2Normalization4dTest, DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Normalization1dNhwc, L2Normalization1dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Normalization2dNhwc, L2Normalization2dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Normalization3dNhwc, L2Normalization3dTest, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Normalization4dNhwc, L2Normalization4dTest, DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Normalization1d, ClContextControlFixture, L2Normalization1dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Normalization2d, ClContextControlFixture, L2Normalization2dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Normalization3d, ClContextControlFixture, L2Normalization3dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Normalization4d, ClContextControlFixture, L2Normalization4dTest, DataLayout::NCHW) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Normalization1dNhwc, + ClContextControlFixture, + L2Normalization1dTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Normalization2dNhwc, + ClContextControlFixture, + L2Normalization2dTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Normalization3dNhwc, + ClContextControlFixture, + L2Normalization3dTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Normalization4dNhwc, + ClContextControlFixture, + L2Normalization4dTest, + DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2Normalization2dShape, L2Normalization2dShapeTest); +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2Normalization2dShape, ClContextControlFixture, L2Normalization2dShapeTest); -ARMNN_AUTO_TEST_CASE_WITH_THF(L2NormalizationDefaultEpsilon, L2NormalizationDefaultEpsilonTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(L2NormalizationNonDefaultEpsilon, L2NormalizationNonDefaultEpsilonTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2NormalizationDefaultEpsilon, + ClContextControlFixture, + L2NormalizationDefaultEpsilonTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(L2NormalizationNonDefaultEpsilon, + ClContextControlFixture, + L2NormalizationNonDefaultEpsilonTest, + DataLayout::NCHW) // Constant -ARMNN_AUTO_TEST_CASE_WITH_THF(Constant, ConstantTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ConstantUint8, ConstantUint8SimpleQuantizationScaleNoOffsetTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Constant, ClContextControlFixture, ConstantTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ConstantUint8, + ClContextControlFixture, + ConstantUint8SimpleQuantizationScaleNoOffsetTest) // Concat -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat1d, Concat1dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat1dUint8, Concat1dUint8Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat2dDim0, Concat2dDim0Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat2dDim0Uint8, Concat2dDim0Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat2dDim1, Concat2dDim1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat2dDim1Uint8, Concat2dDim1Uint8Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat2dDim0DiffInputDims, Concat2dDim0DiffInputDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat2dDim0DiffInputDimsUint8, Concat2dDim0DiffInputDimsUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat2dDim1DiffInputDims, Concat2dDim1DiffInputDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat2dDim1DiffInputDimsUint8, Concat2dDim1DiffInputDimsUint8Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim0, Concat3dDim0Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim0Uint8, Concat3dDim0Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim1, Concat3dDim1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim1Uint8, Concat3dDim1Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim2, Concat3dDim2Test, false) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim2Uint8, Concat3dDim2Uint8Test, false) - -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim0DiffInputDims, Concat3dDim0DiffInputDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim0DiffInputDimsUint8, Concat3dDim0DiffInputDimsUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim1DiffInputDims, Concat3dDim1DiffInputDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim1DiffInputDimsUint8, Concat3dDim1DiffInputDimsUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim2DiffInputDims, Concat3dDim2DiffInputDimsTest, false) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat3dDim2DiffInputDimsUint8, Concat3dDim2DiffInputDimsUint8Test, false) - -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDim0, Concat4dDim0Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDim1, Concat4dDim1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDim3, Concat4dDim3Test, false) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDim0Uint8, Concat4dDim0Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDim1Uint8, Concat4dDim1Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDim3Uint8, Concat4dDim3Uint8Test, false) - -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDiffShapeDim0, Concat4dDiffShapeDim0Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDiffShapeDim1, Concat4dDiffShapeDim1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDiffShapeDim3, Concat4dDiffShapeDim3Test, false) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDiffShapeDim0Uint8, Concat4dDiffShapeDim0Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDiffShapeDim1Uint8, Concat4dDiffShapeDim1Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Concat4dDiffShapeDim3Uint8, Concat4dDiffShapeDim3Uint8Test, false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat1d, ClContextControlFixture, Concat1dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat1dUint8, ClContextControlFixture, Concat1dUint8Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat2dDim0, ClContextControlFixture, Concat2dDim0Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat2dDim0Uint8, ClContextControlFixture, Concat2dDim0Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat2dDim1, ClContextControlFixture, Concat2dDim1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat2dDim1Uint8, ClContextControlFixture, Concat2dDim1Uint8Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat2dDim0DiffInputDims, + ClContextControlFixture, + Concat2dDim0DiffInputDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat2dDim0DiffInputDimsUint8, + ClContextControlFixture, + Concat2dDim0DiffInputDimsUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat2dDim1DiffInputDims, + ClContextControlFixture, + Concat2dDim1DiffInputDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat2dDim1DiffInputDimsUint8, + ClContextControlFixture, + Concat2dDim1DiffInputDimsUint8Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim0, ClContextControlFixture, Concat3dDim0Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim0Uint8, ClContextControlFixture, Concat3dDim0Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim1, ClContextControlFixture, Concat3dDim1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim1Uint8, ClContextControlFixture, Concat3dDim1Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim2, ClContextControlFixture, Concat3dDim2Test, false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim2Uint8, ClContextControlFixture, Concat3dDim2Uint8Test, false) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim0DiffInputDims, ClContextControlFixture, Concat3dDim0DiffInputDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim0DiffInputDimsUint8, + ClContextControlFixture, + Concat3dDim0DiffInputDimsUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim1DiffInputDims, + ClContextControlFixture, + Concat3dDim1DiffInputDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim1DiffInputDimsUint8, + ClContextControlFixture, + Concat3dDim1DiffInputDimsUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim2DiffInputDims, + ClContextControlFixture, + Concat3dDim2DiffInputDimsTest, + false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat3dDim2DiffInputDimsUint8, + ClContextControlFixture, + Concat3dDim2DiffInputDimsUint8Test, + false) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDim0, ClContextControlFixture, Concat4dDim0Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDim1, ClContextControlFixture, Concat4dDim1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDim3, ClContextControlFixture, Concat4dDim3Test, false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDim0Uint8, ClContextControlFixture, Concat4dDim0Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDim1Uint8, ClContextControlFixture, Concat4dDim1Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDim3Uint8, ClContextControlFixture, Concat4dDim3Uint8Test, false) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDiffShapeDim0, ClContextControlFixture, Concat4dDiffShapeDim0Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDiffShapeDim1, ClContextControlFixture, Concat4dDiffShapeDim1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDiffShapeDim3, ClContextControlFixture, Concat4dDiffShapeDim3Test, false) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDiffShapeDim0Uint8, ClContextControlFixture, Concat4dDiffShapeDim0Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDiffShapeDim1Uint8, ClContextControlFixture, Concat4dDiffShapeDim1Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat4dDiffShapeDim3Uint8, + ClContextControlFixture, + Concat4dDiffShapeDim3Uint8Test, + false) // DepthToSpace -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_1, DepthToSpaceTest1, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_2, DepthToSpaceTest2, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_3, DepthToSpaceTest3, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_4, DepthToSpaceTest4, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_1, DepthToSpaceTest1, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_2, DepthToSpaceTest2, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_3, DepthToSpaceTest3, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_4, DepthToSpaceTest4, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt8_1, DepthToSpaceTest1, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt8_2, DepthToSpaceTest2, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt8_3, DepthToSpaceTest3, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt8_4, DepthToSpaceTest4, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_1, DepthToSpaceTest1, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_2, DepthToSpaceTest2, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_3, DepthToSpaceTest3, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_4, DepthToSpaceTest4, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_1, DepthToSpaceTest1, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_2, DepthToSpaceTest2, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_3, DepthToSpaceTest3, DataLayout::NCHW); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_4, DepthToSpaceTest4, DataLayout::NCHW); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_1, DepthToSpaceTest1, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_2, DepthToSpaceTest2, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_3, DepthToSpaceTest3, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_4, DepthToSpaceTest4, DataLayout::NHWC); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_1, DepthToSpaceTest1, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_2, DepthToSpaceTest2, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_3, DepthToSpaceTest3, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_4, DepthToSpaceTest4, DataLayout::NHWC); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt8_1, DepthToSpaceTest1, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt8_2, DepthToSpaceTest2, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt8_3, DepthToSpaceTest3, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt8_4, DepthToSpaceTest4, DataLayout::NHWC); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_1, DepthToSpaceTest1, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_2, DepthToSpaceTest2, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_3, DepthToSpaceTest3, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_4, DepthToSpaceTest4, DataLayout::NHWC); - -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_1, DepthToSpaceTest1, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_2, DepthToSpaceTest2, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_3, DepthToSpaceTest3, DataLayout::NHWC); -ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_4, DepthToSpaceTest4, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat32_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat32_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat32_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat32_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NCHW); + +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat16_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat16_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat16_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat16_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NCHW); + +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt8_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt8_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt8_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt8_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NCHW); + +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwUint8_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwUint8_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwUint8_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwUint8_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NCHW); + +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt16_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt16_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt16_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NCHW); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt16_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NCHW); + +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat32_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat32_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat32_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat32_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NHWC); + +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat16_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat16_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat16_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat16_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NHWC); + +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt8_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt8_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt8_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt8_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NHWC); + +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcUint8_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcUint8_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcUint8_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcUint8_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NHWC); + +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt16_1, + ClContextControlFixture, DepthToSpaceTest1, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt16_2, + ClContextControlFixture, DepthToSpaceTest2, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt16_3, + ClContextControlFixture, DepthToSpaceTest3, DataLayout::NHWC); +ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt16_4, + ClContextControlFixture, DepthToSpaceTest4, DataLayout::NHWC); // Fill -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFill, SimpleFillTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFillF16, SimpleFillTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFillS32, SimpleFillTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFill, ClContextControlFixture, SimpleFillTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFillF16, ClContextControlFixture, SimpleFillTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFillS32, ClContextControlFixture, SimpleFillTest) // FloorPreluUint8 -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFloor, SimpleFloorTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFloor, ClContextControlFixture, SimpleFloorTest) // Gather -ARMNN_AUTO_TEST_CASE_WITH_THF(Gather1dParamsFloat32, Gather1dParamsFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(Gather1dParamsUint8, Gather1dParamsUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GatherMultiDimParamsFloat32, GatherMultiDimParamsFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GatherMultiDimParamsUint8, GatherMultiDimParamsUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Gather1dParamsFloat32, ClContextControlFixture, Gather1dParamsFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Gather1dParamsUint8, ClContextControlFixture, Gather1dParamsUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(GatherMultiDimParamsFloat32, ClContextControlFixture, GatherMultiDimParamsFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(GatherMultiDimParamsUint8, ClContextControlFixture, GatherMultiDimParamsUint8Test) // Reshape -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeFloat32, SimpleReshapeTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeInt8, SimpleReshapeTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeUint8, SimpleReshapeTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Reshape5d, Reshape5dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReshapeBoolean, ReshapeBooleanTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleReshapeFloat32, ClContextControlFixture, SimpleReshapeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleReshapeInt8, ClContextControlFixture, SimpleReshapeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleReshapeUint8, ClContextControlFixture, SimpleReshapeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Reshape5d, ClContextControlFixture, Reshape5dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReshapeBoolean, ClContextControlFixture, ReshapeBooleanTest) // Pad -ARMNN_AUTO_TEST_CASE_WITH_THF(PadFloat322d, PadFloat322dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PadFloat322dCustomPadding, PadFloat322dCustomPaddingTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PadFloat323d, PadFloat323dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PadFloat324d, PadFloat324dTest) - -ARMNN_AUTO_TEST_CASE_WITH_THF(PadUint82d, PadUint82dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PadUint82dCustomPadding, PadUint82dCustomPaddingTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PadUint83d, PadUint83dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PadUint84d, PadUint84dTest) - -ARMNN_AUTO_TEST_CASE_WITH_THF(Pad2dQSymm16, Pad2dTestCommon, 2.0f, 0, 0.0f) -ARMNN_AUTO_TEST_CASE_WITH_THF(Pad2dQSymm16CustomPadding, Pad2dTestCommon, 2.0f, 0, 1.0f) -ARMNN_AUTO_TEST_CASE_WITH_THF(Pad3dQSymm16, Pad3dTestCommon, 2.0f, 0) -ARMNN_AUTO_TEST_CASE_WITH_THF(Pad4dQSymm16, Pad4dTestCommon, 2.0f, 0) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PadFloat322d, ClContextControlFixture, PadFloat322dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PadFloat322dCustomPadding, ClContextControlFixture, PadFloat322dCustomPaddingTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PadFloat323d, ClContextControlFixture, PadFloat323dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PadFloat324d, ClContextControlFixture, PadFloat324dTest) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PadUint82d, ClContextControlFixture, PadUint82dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PadUint82dCustomPadding, ClContextControlFixture, PadUint82dCustomPaddingTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PadUint83d, ClContextControlFixture, PadUint83dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PadUint84d, ClContextControlFixture, PadUint84dTest) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Pad2dQSymm16, + ClContextControlFixture, Pad2dTestCommon, 2.0f, 0, 0.0f) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Pad2dQSymm16CustomPadding, + ClContextControlFixture, Pad2dTestCommon, 2.0f, 0, 1.0f) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Pad3dQSymm16, ClContextControlFixture, Pad3dTestCommon, 2.0f, 0) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Pad4dQSymm16, ClContextControlFixture, Pad4dTestCommon, 2.0f, 0) // PReLU -ARMNN_AUTO_TEST_CASE_WITH_THF(PreluFloat32, PreluTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PreluUint8, PreluTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PreluFloat32, ClContextControlFixture, PreluTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PreluUint8, ClContextControlFixture, PreluTest) // Permute -ARMNN_AUTO_TEST_CASE_WITH_THF(SimplePermuteFloat32, SimplePermuteTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteFloat32ValueSet1Test, PermuteValueSet1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteFloat32ValueSet2Test, PermuteValueSet2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteFloat32ValueSet3Test, PermuteValueSet3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimplePermuteQASymmS8, SimplePermuteTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymmS8ValueSet1Test, PermuteValueSet1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymmS8ValueSet2Test, PermuteValueSet2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymmS8ValueSet3Test, PermuteValueSet3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimplePermuteQASymm8, SimplePermuteTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymm8ValueSet1Test, PermuteValueSet1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymm8ValueSet2Test, PermuteValueSet2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymm8ValueSet3Test, PermuteValueSet3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimplePermuteFloat32, ClContextControlFixture, SimplePermuteTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + PermuteFloat32ValueSet1Test, ClContextControlFixture, PermuteValueSet1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + PermuteFloat32ValueSet2Test, ClContextControlFixture, PermuteValueSet2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + PermuteFloat32ValueSet3Test, ClContextControlFixture, PermuteValueSet3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SimplePermuteQASymmS8, ClContextControlFixture, SimplePermuteTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + PermuteQASymmS8ValueSet1Test, ClContextControlFixture, PermuteValueSet1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + PermuteQASymmS8ValueSet2Test, ClContextControlFixture, PermuteValueSet2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + PermuteQASymmS8ValueSet3Test, ClContextControlFixture, PermuteValueSet3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SimplePermuteQASymm8, ClContextControlFixture, SimplePermuteTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + PermuteQASymm8ValueSet1Test, ClContextControlFixture, PermuteValueSet1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + PermuteQASymm8ValueSet2Test, ClContextControlFixture, PermuteValueSet2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + PermuteQASymm8ValueSet3Test, ClContextControlFixture, PermuteValueSet3Test) // Lstm -ARMNN_AUTO_TEST_CASE_WITH_THF(LstmLayerFloat32WithCifgWithPeepholeNoProjection, +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LstmLayerFloat32WithCifgWithPeepholeNoProjection, ClContextControlFixture, LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LstmLayerFloat32NoCifgNoPeepholeNoProjection, +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LstmLayerFloat32NoCifgNoPeepholeNoProjection, ClContextControlFixture, LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LstmLayerFloat32NoCifgWithPeepholeWithProjection, +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LstmLayerFloat32NoCifgWithPeepholeWithProjection, ClContextControlFixture, LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNorm, - LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNormTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNorm, + ClContextControlFixture, + LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNormTest) // QLstm -ARMNN_AUTO_TEST_CASE_WITH_THF(QLstm, QLstmTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(QLstm1, QLstmTest1) -ARMNN_AUTO_TEST_CASE_WITH_THF(QLstm2, QLstmTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(QLstm, ClContextControlFixture, QLstmTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(QLstm1, ClContextControlFixture, QLstmTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(QLstm2, ClContextControlFixture, QLstmTest2) // QuantizedLstm -ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizedLstm, QuantizedLstmTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(QuantizedLstm, ClContextControlFixture, QuantizedLstmTest) // Convert from Float16 to Float32 -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvertFp16ToFp32, SimpleConvertFp16ToFp32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvertFp16ToFp32, ClContextControlFixture, SimpleConvertFp16ToFp32Test) // Convert from Float32 to Float16 -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvertFp32ToFp16, SimpleConvertFp32ToFp16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvertFp32ToFp16, ClContextControlFixture, SimpleConvertFp32ToFp16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(AdditionAfterMaxPool, AdditionAfterMaxPoolTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AdditionAfterMaxPool, ClContextControlFixture, AdditionAfterMaxPoolTest) //Max -ARMNN_AUTO_TEST_CASE_WITH_THF(MaximumSimple, MaximumSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MaximumBroadcast1Element, MaximumBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MaximumBroadcast1DVector, MaximumBroadcast1DVectorTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MaximumUint8, MaximumUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MaximumBroadcast1ElementUint8, MaximumBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MaximumBroadcast1DVectorUint8, MaximumBroadcast1DVectorUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MaximumSimple, ClContextControlFixture, MaximumSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MaximumBroadcast1Element, ClContextControlFixture, MaximumBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MaximumBroadcast1DVector, ClContextControlFixture, MaximumBroadcast1DVectorTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MaximumUint8, ClContextControlFixture, MaximumUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MaximumBroadcast1ElementUint8, ClContextControlFixture, MaximumBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MaximumBroadcast1DVectorUint8, ClContextControlFixture, MaximumBroadcast1DVectorUint8Test) // Mean -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleFloat32, MeanSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleAxisFloat32, MeanSimpleAxisTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanKeepDimsFloat32, MeanKeepDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanMultipleDimsFloat32, MeanMultipleDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts1Float32, MeanVts1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts2Float32, MeanVts2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts3Float32, MeanVts3Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleQuantisedAsymmS8, MeanSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleAxisQuantisedAsymmS8, MeanSimpleAxisTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanKeepDimsQuantisedAsymmS8, MeanKeepDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanMultipleDimsQuantisedAsymmS8, MeanMultipleDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts1QuantisedAsymmS8, MeanVts1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts2QuantisedAsymmS8, MeanVts2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts3QuantisedAsymmS8, MeanVts3Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleQuantisedAsymm8, MeanSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleAxisQuantisedAsymm8, MeanSimpleAxisTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanKeepDimsQuantisedAsymm8, MeanKeepDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanMultipleDimsQuantisedAsymm8, MeanMultipleDimsTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts1QuantisedAsymm8, MeanVts1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts2QuantisedAsymm8, MeanVts2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts3QuantisedAsymm8, MeanVts3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanSimpleFloat32, ClContextControlFixture, MeanSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanSimpleAxisFloat32, ClContextControlFixture, MeanSimpleAxisTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanKeepDimsFloat32, ClContextControlFixture, MeanKeepDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MeanMultipleDimsFloat32, ClContextControlFixture, MeanMultipleDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts1Float32, ClContextControlFixture, MeanVts1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts2Float32, ClContextControlFixture, MeanVts2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts3Float32, ClContextControlFixture, MeanVts3Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MeanSimpleQuantisedAsymmS8, ClContextControlFixture, MeanSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MeanSimpleAxisQuantisedAsymmS8, ClContextControlFixture, MeanSimpleAxisTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MeanKeepDimsQuantisedAsymmS8, ClContextControlFixture, MeanKeepDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MeanMultipleDimsQuantisedAsymmS8, ClContextControlFixture, MeanMultipleDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts1QuantisedAsymmS8, ClContextControlFixture, MeanVts1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts2QuantisedAsymmS8, ClContextControlFixture, MeanVts2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts3QuantisedAsymmS8, ClContextControlFixture, MeanVts3Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MeanSimpleQuantisedAsymm8, ClContextControlFixture, MeanSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MeanSimpleAxisQuantisedAsymm8, ClContextControlFixture, MeanSimpleAxisTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MeanKeepDimsQuantisedAsymm8, ClContextControlFixture, MeanKeepDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MeanMultipleDimsQuantisedAsymm8, ClContextControlFixture, MeanMultipleDimsTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts1QuantisedAsymm8, ClContextControlFixture, MeanVts1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts2QuantisedAsymm8, ClContextControlFixture, MeanVts2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts3QuantisedAsymm8, ClContextControlFixture, MeanVts3Test) // Minimum -ARMNN_AUTO_TEST_CASE_WITH_THF(MinimumBroadcast1Element1, MinimumBroadcast1ElementTest1) -ARMNN_AUTO_TEST_CASE_WITH_THF(MinimumBroadcast1Element2, MinimumBroadcast1ElementTest2) -ARMNN_AUTO_TEST_CASE_WITH_THF(MinimumBroadcast1DVectorUint8, MinimumBroadcast1DVectorUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MinimumBroadcast1Element1, ClContextControlFixture, MinimumBroadcast1ElementTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MinimumBroadcast1Element2, ClContextControlFixture, MinimumBroadcast1ElementTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + MinimumBroadcast1DVectorUint8, ClContextControlFixture, MinimumBroadcast1DVectorUint8Test) // Equal -ARMNN_AUTO_TEST_CASE_WITH_THF(EqualSimple, EqualSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(EqualBroadcast1Element, EqualBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(EqualBroadcast1dVector, EqualBroadcast1dVectorTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(EqualSimple, ClContextControlFixture, EqualSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(EqualBroadcast1Element, ClContextControlFixture, EqualBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(EqualBroadcast1dVector, ClContextControlFixture, EqualBroadcast1dVectorTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(EqualSimpleFloat16, EqualSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(EqualBroadcast1ElementFloat16, EqualBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(EqualBroadcast1dVectorFloat16, EqualBroadcast1dVectorFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(EqualSimpleFloat16, ClContextControlFixture, EqualSimpleFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + EqualBroadcast1ElementFloat16, ClContextControlFixture, EqualBroadcast1ElementFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + EqualBroadcast1dVectorFloat16, ClContextControlFixture, EqualBroadcast1dVectorFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(EqualSimpleUint8, EqualSimpleUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(EqualBroadcast1ElementUint8, EqualBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(EqualBroadcast1dVectorUint8, EqualBroadcast1dVectorUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(EqualSimpleUint8, ClContextControlFixture, EqualSimpleUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(EqualBroadcast1ElementUint8, ClContextControlFixture, EqualBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(EqualBroadcast1dVectorUint8, ClContextControlFixture, EqualBroadcast1dVectorUint8Test) // Greater -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterSimple, GreaterSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterBroadcast1Element, GreaterBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterBroadcast1dVector, GreaterBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterSimpleFloat16, GreaterSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterBroadcast1ElementFloat16, GreaterBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterBroadcast1dVectorFloat16, GreaterBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterSimpleUint8, GreaterSimpleUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterBroadcast1ElementUint8, GreaterBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterBroadcast1dVectorUint8, GreaterBroadcast1dVectorUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(GreaterSimple, ClContextControlFixture, GreaterSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(GreaterBroadcast1Element, ClContextControlFixture, GreaterBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(GreaterBroadcast1dVector, ClContextControlFixture, GreaterBroadcast1dVectorTest) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(GreaterSimpleFloat16, ClContextControlFixture, GreaterSimpleFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterBroadcast1ElementFloat16, ClContextControlFixture, GreaterBroadcast1ElementFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterBroadcast1dVectorFloat16, ClContextControlFixture, GreaterBroadcast1dVectorFloat16Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(GreaterSimpleUint8, ClContextControlFixture, GreaterSimpleUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterBroadcast1ElementUint8, ClContextControlFixture, GreaterBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterBroadcast1dVectorUint8, ClContextControlFixture, GreaterBroadcast1dVectorUint8Test) // GreaterOrEqual -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualSimple, GreaterOrEqualSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualBroadcast1Element, GreaterOrEqualBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualBroadcast1dVector, GreaterOrEqualBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualSimpleFloat16, GreaterOrEqualSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualBroadcast1ElementFloat16, GreaterOrEqualBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualBroadcast1dVectorFloat16, GreaterOrEqualBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualSimpleUint8, GreaterOrEqualSimpleUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualBroadcast1ElementUint8, GreaterOrEqualBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualBroadcast1dVectorUint8, GreaterOrEqualBroadcast1dVectorUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(GreaterOrEqualSimple, ClContextControlFixture, GreaterOrEqualSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterOrEqualBroadcast1Element, ClContextControlFixture, GreaterOrEqualBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterOrEqualBroadcast1dVector, ClContextControlFixture, GreaterOrEqualBroadcast1dVectorTest) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterOrEqualSimpleFloat16, ClContextControlFixture, GreaterOrEqualSimpleFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterOrEqualBroadcast1ElementFloat16, ClContextControlFixture, GreaterOrEqualBroadcast1ElementFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterOrEqualBroadcast1dVectorFloat16, ClContextControlFixture, GreaterOrEqualBroadcast1dVectorFloat16Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(GreaterOrEqualSimpleUint8, ClContextControlFixture, GreaterOrEqualSimpleUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterOrEqualBroadcast1ElementUint8, ClContextControlFixture, GreaterOrEqualBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + GreaterOrEqualBroadcast1dVectorUint8, ClContextControlFixture, GreaterOrEqualBroadcast1dVectorUint8Test) // Less -ARMNN_AUTO_TEST_CASE_WITH_THF(LessSimple, LessSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessBroadcast1Element, LessBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessBroadcast1dVector, LessBroadcast1dVectorTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessSimple, ClContextControlFixture, LessSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessBroadcast1Element, ClContextControlFixture, LessBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessBroadcast1dVector, ClContextControlFixture, LessBroadcast1dVectorTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessSimpleFloat16, LessSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessBroadcast1ElementFloat16, LessBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessBroadcast1dVectorFloat16, LessBroadcast1dVectorFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessSimpleFloat16, ClContextControlFixture, LessSimpleFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + LessBroadcast1ElementFloat16, ClContextControlFixture, LessBroadcast1ElementFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + LessBroadcast1dVectorFloat16, ClContextControlFixture, LessBroadcast1dVectorFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessSimpleUint8, LessSimpleUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessBroadcast1ElementUint8, LessBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessBroadcast1dVectorUint8, LessBroadcast1dVectorUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessSimpleUint8, ClContextControlFixture, LessSimpleUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessBroadcast1ElementUint8, ClContextControlFixture, LessBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessBroadcast1dVectorUint8, ClContextControlFixture, LessBroadcast1dVectorUint8Test) // LessOrEqual -ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualSimple, LessOrEqualSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualBroadcast1Element, LessOrEqualBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualBroadcast1dVector, LessOrEqualBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualSimpleFloat16, LessOrEqualSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualBroadcast1ElementFloat16, LessOrEqualBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualBroadcast1dVectorFloat16, LessOrEqualBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualSimpleUint8, LessOrEqualSimpleUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualBroadcast1ElementUint8, LessOrEqualBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualBroadcast1dVectorUint8, LessOrEqualBroadcast1dVectorUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessOrEqualSimple, ClContextControlFixture, LessOrEqualSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + LessOrEqualBroadcast1Element, ClContextControlFixture, LessOrEqualBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + LessOrEqualBroadcast1dVector, ClContextControlFixture, LessOrEqualBroadcast1dVectorTest) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessOrEqualSimpleFloat16, ClContextControlFixture, LessOrEqualSimpleFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + LessOrEqualBroadcast1ElementFloat16, ClContextControlFixture, LessOrEqualBroadcast1ElementFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + LessOrEqualBroadcast1dVectorFloat16, ClContextControlFixture, LessOrEqualBroadcast1dVectorFloat16Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LessOrEqualSimpleUint8, ClContextControlFixture, LessOrEqualSimpleUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + LessOrEqualBroadcast1ElementUint8, ClContextControlFixture, LessOrEqualBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + LessOrEqualBroadcast1dVectorUint8, ClContextControlFixture, LessOrEqualBroadcast1dVectorUint8Test) // NotEqual -ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualSimple, NotEqualSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1Element, NotEqualBroadcast1ElementTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1dVector, NotEqualBroadcast1dVectorTest) - -ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualSimpleFloat16, NotEqualSimpleFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1ElementFloat16, NotEqualBroadcast1ElementFloat16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1dVectorFloat16, NotEqualBroadcast1dVectorFloat16Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualSimpleUint8, NotEqualSimpleUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1ElementUint8, NotEqualBroadcast1ElementUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1dVectorUint8, NotEqualBroadcast1dVectorUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(NotEqualSimple, ClContextControlFixture, NotEqualSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(NotEqualBroadcast1Element, ClContextControlFixture, NotEqualBroadcast1ElementTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(NotEqualBroadcast1dVector, ClContextControlFixture, NotEqualBroadcast1dVectorTest) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(NotEqualSimpleFloat16, ClContextControlFixture, NotEqualSimpleFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + NotEqualBroadcast1ElementFloat16, ClContextControlFixture, NotEqualBroadcast1ElementFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + NotEqualBroadcast1dVectorFloat16, ClContextControlFixture, NotEqualBroadcast1dVectorFloat16Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(NotEqualSimpleUint8, ClContextControlFixture, NotEqualSimpleUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + NotEqualBroadcast1ElementUint8, ClContextControlFixture, NotEqualBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + NotEqualBroadcast1dVectorUint8, ClContextControlFixture, NotEqualBroadcast1dVectorUint8Test) // Softmax -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleSoftmaxBeta1, SimpleSoftmaxTest, 1.0f) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleSoftmaxBeta2, SimpleSoftmaxTest, 2.0f) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleSoftmaxBeta1Uint8, SimpleSoftmaxUint8Test, 1.0f) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleSoftmaxBeta2Uint8, SimpleSoftmaxUint8Test, 2.0f) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleSoftmaxBeta1, ClContextControlFixture, SimpleSoftmaxTest, 1.0f) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleSoftmaxBeta2, ClContextControlFixture, SimpleSoftmaxTest, 2.0f) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleSoftmaxBeta1Uint8, ClContextControlFixture, SimpleSoftmaxUint8Test, 1.0f) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleSoftmaxBeta2Uint8, ClContextControlFixture, SimpleSoftmaxUint8Test, 2.0f) // LogSoftmax -ARMNN_AUTO_TEST_CASE_WITH_THF(LogSoftmaxFloat32_1, LogSoftmaxTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogSoftmaxFloat32_1, ClContextControlFixture, LogSoftmaxTest1) // Space To Batch Nd -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdSimpleFloat32, SpaceToBatchNdSimpleFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdMultiChannelsFloat32, SpaceToBatchNdMultiChannelsFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdMultiBlockFloat32, SpaceToBatchNdMultiBlockFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdPaddingFloat32, SpaceToBatchNdPaddingFloat32Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdSimpleUint8, SpaceToBatchNdSimpleUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdMultiChannelsUint8, SpaceToBatchNdMultiChannelsUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdMultiBlockUint8, SpaceToBatchNdMultiBlockUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdPaddingUint8, SpaceToBatchNdPaddingUint8Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdSimpleNhwcFloat32, SpaceToBatchNdSimpleNhwcFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdMultiChannelsNhwcFloat32, SpaceToBatchNdMultiChannelsNhwcFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdMultiBlockNhwcFloat32, SpaceToBatchNdMultiBlockNhwcFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdPaddingNhwcFloat32, SpaceToBatchNdPaddingNhwcFloat32Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdSimpleNhwcUint8, SpaceToBatchNdSimpleNhwcUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdMultiChannelsNhwcUint8, SpaceToBatchNdMultiChannelsNhwcUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdMultiBlockNhwcUint8, SpaceToBatchNdMultiBlockNhwcUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToBatchNdPaddingNhwcUint8, SpaceToBatchNdPaddingNhwcUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToBatchNdSimpleFloat32, ClContextControlFixture, SpaceToBatchNdSimpleFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdMultiChannelsFloat32, ClContextControlFixture, SpaceToBatchNdMultiChannelsFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdMultiBlockFloat32, ClContextControlFixture, SpaceToBatchNdMultiBlockFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdPaddingFloat32, ClContextControlFixture, SpaceToBatchNdPaddingFloat32Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToBatchNdSimpleUint8, ClContextControlFixture, SpaceToBatchNdSimpleUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdMultiChannelsUint8, ClContextControlFixture, SpaceToBatchNdMultiChannelsUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdMultiBlockUint8, ClContextControlFixture, SpaceToBatchNdMultiBlockUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdPaddingUint8, ClContextControlFixture, SpaceToBatchNdPaddingUint8Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdSimpleNhwcFloat32, ClContextControlFixture, SpaceToBatchNdSimpleNhwcFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdMultiChannelsNhwcFloat32, ClContextControlFixture, SpaceToBatchNdMultiChannelsNhwcFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdMultiBlockNhwcFloat32, ClContextControlFixture, SpaceToBatchNdMultiBlockNhwcFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdPaddingNhwcFloat32, ClContextControlFixture, SpaceToBatchNdPaddingNhwcFloat32Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdSimpleNhwcUint8, ClContextControlFixture, SpaceToBatchNdSimpleNhwcUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdMultiChannelsNhwcUint8, ClContextControlFixture, SpaceToBatchNdMultiChannelsNhwcUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdMultiBlockNhwcUint8, ClContextControlFixture, SpaceToBatchNdMultiBlockNhwcUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SpaceToBatchNdPaddingNhwcUint8, ClContextControlFixture, SpaceToBatchNdPaddingNhwcUint8Test) // Space To Depth -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNhwcAsymmQ8, SpaceToDepthNhwcAsymmQ8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNchwAsymmQ8, SpaceToDepthNchwAsymmQ8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToDepthNhwcAsymmQ8, ClContextControlFixture, SpaceToDepthNhwcAsymmQ8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToDepthNchwAsymmQ8, ClContextControlFixture, SpaceToDepthNchwAsymmQ8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNhwx1Float32, SpaceToDepthNhwcFloat32Test1) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNchw1Float32, SpaceToDepthNchwFloat32Test1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToDepthNhwx1Float32, ClContextControlFixture, SpaceToDepthNhwcFloat32Test1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToDepthNchw1Float32, ClContextControlFixture, SpaceToDepthNchwFloat32Test1) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNhwc2Float32, SpaceToDepthNhwcFloat32Test2) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNchw2Float32, SpaceToDepthNchwFloat32Test2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToDepthNhwc2Float32, ClContextControlFixture, SpaceToDepthNhwcFloat32Test2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToDepthNchw2Float32, ClContextControlFixture, SpaceToDepthNchwFloat32Test2) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNhwcQSymm16, SpaceToDepthNhwcQSymm16Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNchwQSymm16, SpaceToDepthNchwQSymm16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToDepthNhwcQSymm16, ClContextControlFixture, SpaceToDepthNhwcQSymm16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SpaceToDepthNchwQSymm16, ClContextControlFixture, SpaceToDepthNchwQSymm16Test) // Stack -ARMNN_AUTO_TEST_CASE_WITH_THF(Stack0Axis, StackAxis0Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StackOutput4DAxis1, StackOutput4DAxis1Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StackOutput4DAxis2, StackOutput4DAxis2Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StackOutput4DAxis3, StackOutput4DAxis3Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StackOutput3DInputs3, StackOutput3DInputs3Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StackOutput5D, StackOutput5DFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StackFloat16, StackFloat16Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Stack0Axis, ClContextControlFixture, StackAxis0Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StackOutput4DAxis1, ClContextControlFixture, StackOutput4DAxis1Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StackOutput4DAxis2, ClContextControlFixture, StackOutput4DAxis2Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StackOutput4DAxis3, ClContextControlFixture, StackOutput4DAxis3Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StackOutput3DInputs3, ClContextControlFixture, StackOutput3DInputs3Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StackOutput5D, ClContextControlFixture, StackOutput5DFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StackFloat16, ClContextControlFixture, StackFloat16Test) // Slice -ARMNN_AUTO_TEST_CASE(Slice4dFloat32, Slice4dFloat32Test) -ARMNN_AUTO_TEST_CASE(Slice3dFloat32, Slice3dFloat32Test) -ARMNN_AUTO_TEST_CASE(Slice2dFloat32, Slice2dFloat32Test) -ARMNN_AUTO_TEST_CASE(Slice1dFloat32, Slice1dFloat32Test) -ARMNN_AUTO_TEST_CASE(Slice4dUint8, Slice4dUint8Test) -ARMNN_AUTO_TEST_CASE(Slice3dUint8, Slice3dUint8Test) -ARMNN_AUTO_TEST_CASE(Slice2dUint8, Slice2dUint8Test) -ARMNN_AUTO_TEST_CASE(Slice1dUint8, Slice1dUint8Test) -ARMNN_AUTO_TEST_CASE(Slice4dInt16, Slice4dInt16Test) -ARMNN_AUTO_TEST_CASE(Slice3dInt16, Slice3dInt16Test) -ARMNN_AUTO_TEST_CASE(Slice2dInt16, Slice2dInt16Test) -ARMNN_AUTO_TEST_CASE(Slice1dInt16, Slice1dInt16Test) +ARMNN_AUTO_TEST_FIXTURE(Slice4dFloat32, ClContextControlFixture, Slice4dFloat32Test) +ARMNN_AUTO_TEST_FIXTURE(Slice3dFloat32, ClContextControlFixture, Slice3dFloat32Test) +ARMNN_AUTO_TEST_FIXTURE(Slice2dFloat32, ClContextControlFixture, Slice2dFloat32Test) +ARMNN_AUTO_TEST_FIXTURE(Slice1dFloat32, ClContextControlFixture, Slice1dFloat32Test) +ARMNN_AUTO_TEST_FIXTURE(Slice4dUint8, ClContextControlFixture, Slice4dUint8Test) +ARMNN_AUTO_TEST_FIXTURE(Slice3dUint8, ClContextControlFixture, Slice3dUint8Test) +ARMNN_AUTO_TEST_FIXTURE(Slice2dUint8, ClContextControlFixture, Slice2dUint8Test) +ARMNN_AUTO_TEST_FIXTURE(Slice1dUint8, ClContextControlFixture, Slice1dUint8Test) +ARMNN_AUTO_TEST_FIXTURE(Slice4dInt16, ClContextControlFixture, Slice4dInt16Test) +ARMNN_AUTO_TEST_FIXTURE(Slice3dInt16, ClContextControlFixture, Slice3dInt16Test) +ARMNN_AUTO_TEST_FIXTURE(Slice2dInt16, ClContextControlFixture, Slice2dInt16Test) +ARMNN_AUTO_TEST_FIXTURE(Slice1dInt16, ClContextControlFixture, Slice1dInt16Test) // Strided Slice -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice4dFloat32, StridedSlice4dFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice4dReverseFloat32, StridedSlice4dReverseFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceSimpleStrideFloat32, StridedSliceSimpleStrideFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceSimpleRangeMaskFloat32, StridedSliceSimpleRangeMaskFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceShrinkAxisMaskFloat32, StridedSliceShrinkAxisMaskFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceShrinkAxisMaskCTSFloat32, StridedSliceShrinkAxisMaskCTSFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0Dim3Float32, +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSlice4dFloat32, ClContextControlFixture, StridedSlice4dFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSlice4dReverseFloat32, ClContextControlFixture, StridedSlice4dReverseFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSliceSimpleStrideFloat32, ClContextControlFixture, StridedSliceSimpleStrideFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSliceSimpleRangeMaskFloat32, ClContextControlFixture, StridedSliceSimpleRangeMaskFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSliceShrinkAxisMaskFloat32, ClContextControlFixture, StridedSliceShrinkAxisMaskFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSliceShrinkAxisMaskCTSFloat32, ClContextControlFixture, StridedSliceShrinkAxisMaskCTSFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0Dim3Float32, ClContextControlFixture, StridedSliceShrinkAxisMaskBitPosition0Dim3Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0Float32, StridedSliceShrinkAxisMaskBitPosition0Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition1Float32, StridedSliceShrinkAxisMaskBitPosition1Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition2Float32, StridedSliceShrinkAxisMaskBitPosition2Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition3Float32, StridedSliceShrinkAxisMaskBitPosition3Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0And1Float32, StridedSliceShrinkAxisMaskBitPosition0And1Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0And2Float32, StridedSliceShrinkAxisMaskBitPosition0And2Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0And3Float32, StridedSliceShrinkAxisMaskBitPosition0And3Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0And1And3Float32, StridedSliceShrinkAxisMaskBitPosition0And1And3Float32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice3dFloat32, StridedSlice3dFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice3dReverseFloat32, StridedSlice3dReverseFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice2dFloat32, StridedSlice2dFloat32Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice2dReverseFloat32, StridedSlice2dReverseFloat32Test) - -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice4dUint8, StridedSlice4dUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice4dReverseUint8, StridedSlice4dReverseUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceSimpleStrideUint8, StridedSliceSimpleStrideUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceSimpleRangeMaskUint8, StridedSliceSimpleRangeMaskUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSliceShrinkAxisMaskUint8, StridedSliceShrinkAxisMaskUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0Dim3Uint8, StridedSliceShrinkAxisMaskBitPosition0Dim3Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0Uint8, StridedSliceShrinkAxisMaskBitPosition0Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition1Uint8, StridedSliceShrinkAxisMaskBitPosition1Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition2Uint8, StridedSliceShrinkAxisMaskBitPosition2Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition3Uint8, StridedSliceShrinkAxisMaskBitPosition3Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0And1Uint8, StridedSliceShrinkAxisMaskBitPosition0And1Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0And2Uint8, StridedSliceShrinkAxisMaskBitPosition0And2Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0And3Uint8, StridedSliceShrinkAxisMaskBitPosition0And3Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF( - StridedSliceShrinkAxisMaskBitPosition0And1And3Uint8, StridedSliceShrinkAxisMaskBitPosition0And1And3Uint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice3dUint8, StridedSlice3dUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice3dReverseUint8, StridedSlice3dReverseUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice2dUint8, StridedSlice2dUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedSlice2dReverseUint8, StridedSlice2dReverseUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0Float32, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition1Float32, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition1Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition2Float32, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition2Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition3Float32, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition3Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0And1Float32, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0And1Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0And2Float32, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0And2Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0And3Float32, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0And3Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0And1And3Float32, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0And1And3Float32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSlice3dFloat32, + ClContextControlFixture, + StridedSlice3dFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSlice3dReverseFloat32, ClContextControlFixture, StridedSlice3dReverseFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSlice2dFloat32, ClContextControlFixture, StridedSlice2dFloat32Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSlice2dReverseFloat32, ClContextControlFixture, StridedSlice2dReverseFloat32Test) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSlice4dUint8, ClContextControlFixture, StridedSlice4dUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSlice4dReverseUint8, ClContextControlFixture, StridedSlice4dReverseUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSliceSimpleStrideUint8, ClContextControlFixture, StridedSliceSimpleStrideUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSliceSimpleRangeMaskUint8, ClContextControlFixture, StridedSliceSimpleRangeMaskUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + StridedSliceShrinkAxisMaskUint8, ClContextControlFixture, StridedSliceShrinkAxisMaskUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0Dim3Uint8, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0Dim3Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0Uint8, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition1Uint8, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition1Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition2Uint8, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition2Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition3Uint8, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition3Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0And1Uint8, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0And1Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0And2Uint8, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0And2Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0And3Uint8, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0And3Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSliceShrinkAxisMaskBitPosition0And1And3Uint8, + ClContextControlFixture, + StridedSliceShrinkAxisMaskBitPosition0And1And3Uint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSlice3dUint8, ClContextControlFixture, StridedSlice3dUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSlice3dReverseUint8, ClContextControlFixture, StridedSlice3dReverseUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSlice2dUint8, ClContextControlFixture, StridedSlice2dUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedSlice2dReverseUint8, ClContextControlFixture, StridedSlice2dReverseUint8Test) // Resize Bilinear - NCHW -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinear, - SimpleResizeBilinearTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearInt8, - SimpleResizeBilinearTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8, - SimpleResizeBilinearTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNop, - ResizeBilinearNopTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopInt8, - ResizeBilinearNopTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8, - ResizeBilinearNopTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMin, - ResizeBilinearSqMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinInt8, - ResizeBilinearSqMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8, - ResizeBilinearSqMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMin, - ResizeBilinearMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinInt8, - ResizeBilinearMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8, - ResizeBilinearMinTest, - DataLayout::NCHW) - -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinear, - HalfPixelCentersResizeBilinearTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinear, - AlignCornersResizeBilinearTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8, - HalfPixelCentersResizeBilinearTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8, - AlignCornersResizeBilinearTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8, - HalfPixelCentersResizeBilinearTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8, - AlignCornersResizeBilinearTest, - DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinear, + ClContextControlFixture, + SimpleResizeBilinearTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearInt8, + ClContextControlFixture, + SimpleResizeBilinearTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearUint8, + ClContextControlFixture, + SimpleResizeBilinearTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNop, + ClContextControlFixture, + ResizeBilinearNopTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopInt8, + ClContextControlFixture, + ResizeBilinearNopTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopUint8, + ClContextControlFixture, + ResizeBilinearNopTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMin, + ClContextControlFixture, + ResizeBilinearSqMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinInt8, + ClContextControlFixture, + ResizeBilinearSqMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinUint8, + ClContextControlFixture, + ResizeBilinearSqMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMin, + ClContextControlFixture, + ResizeBilinearMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinInt8, + ClContextControlFixture, + ResizeBilinearMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinUint8, + ClContextControlFixture, + ResizeBilinearMinTest, + DataLayout::NCHW) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinear, + ClContextControlFixture, + HalfPixelCentersResizeBilinearTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinear, + ClContextControlFixture, + AlignCornersResizeBilinearTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearInt8, + ClContextControlFixture, + HalfPixelCentersResizeBilinearTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearInt8, + ClContextControlFixture, + AlignCornersResizeBilinearTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearUint8, + ClContextControlFixture, + HalfPixelCentersResizeBilinearTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearUint8, + ClContextControlFixture, + AlignCornersResizeBilinearTest, + DataLayout::NCHW) // Resize Bilinear - NHWC -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopNhwc, - ResizeBilinearNopTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopInt8Nhwc, - ResizeBilinearNopTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8Nhwc, - ResizeBilinearNopTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearNhwc, - SimpleResizeBilinearTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearInt8Nhwc, - SimpleResizeBilinearTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8Nhwc, - SimpleResizeBilinearTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinNhwc, - ResizeBilinearSqMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinInt8Nhwc, - ResizeBilinearSqMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8Nhwc, - ResizeBilinearSqMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinNhwc, - ResizeBilinearMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinInt8Nhwc, - ResizeBilinearMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8Nhwc, - ResizeBilinearMinTest, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearNhwc, - HalfPixelCentersResizeBilinearTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearNhwc, - AlignCornersResizeBilinearTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8Nhwc, - HalfPixelCentersResizeBilinearTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8Nhwc, - AlignCornersResizeBilinearTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8Nhwc, - HalfPixelCentersResizeBilinearTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8Nhwc, - AlignCornersResizeBilinearTest, - DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopNhwc, + ClContextControlFixture, + ResizeBilinearNopTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopInt8Nhwc, + ClContextControlFixture, + ResizeBilinearNopTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopUint8Nhwc, + ClContextControlFixture, + ResizeBilinearNopTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearNhwc, + ClContextControlFixture, + SimpleResizeBilinearTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearInt8Nhwc, + ClContextControlFixture, + SimpleResizeBilinearTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearUint8Nhwc, + ClContextControlFixture, + SimpleResizeBilinearTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinNhwc, + ClContextControlFixture, + ResizeBilinearSqMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinInt8Nhwc, + ClContextControlFixture, + ResizeBilinearSqMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinUint8Nhwc, + ClContextControlFixture, + ResizeBilinearSqMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinNhwc, + ClContextControlFixture, + ResizeBilinearMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinInt8Nhwc, + ClContextControlFixture, + ResizeBilinearMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinUint8Nhwc, + ClContextControlFixture, + ResizeBilinearMinTest, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearNhwc, + ClContextControlFixture, + HalfPixelCentersResizeBilinearTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearNhwc, + ClContextControlFixture, + AlignCornersResizeBilinearTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearInt8Nhwc, + ClContextControlFixture, + HalfPixelCentersResizeBilinearTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearInt8Nhwc, + ClContextControlFixture, + AlignCornersResizeBilinearTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearUint8Nhwc, + ClContextControlFixture, + HalfPixelCentersResizeBilinearTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearUint8Nhwc, + ClContextControlFixture, + AlignCornersResizeBilinearTest, + DataLayout::NHWC) // Resize NearestNeighbor - NCHW -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighbor, - SimpleResizeNearestNeighborTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborInt8, - SimpleResizeNearestNeighborTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8, - SimpleResizeNearestNeighborTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNop, - ResizeNearestNeighborNopTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopInt8, - ResizeNearestNeighborNopTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8, - ResizeNearestNeighborNopTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMin, - ResizeNearestNeighborSqMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinInt8, - ResizeNearestNeighborSqMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8, - ResizeNearestNeighborSqMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMin, - ResizeNearestNeighborMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinInt8, - ResizeNearestNeighborMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8, - ResizeNearestNeighborMinTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMag, - ResizeNearestNeighborMagTest, - DataLayout::NCHW, 0.1f, 50, 0.1f, 50) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagInt8, - ResizeNearestNeighborMagTest, - DataLayout::NCHW, 0.1f, 50, 0.1f, 50) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8, - ResizeNearestNeighborMagTest, - DataLayout::NCHW, 0.1f, 50, 0.1f, 50) - -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbour, - HalfPixelCentersResizeNearestNeighbourTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbour, - AlignCornersResizeNearestNeighbourTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8, - HalfPixelCentersResizeNearestNeighbourTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8, - AlignCornersResizeNearestNeighbourTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8, - HalfPixelCentersResizeNearestNeighbourTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8, - AlignCornersResizeNearestNeighbourTest, - DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighbor, + ClContextControlFixture, + SimpleResizeNearestNeighborTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborInt8, + ClContextControlFixture, + SimpleResizeNearestNeighborTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborUint8, + ClContextControlFixture, + SimpleResizeNearestNeighborTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNop, + ClContextControlFixture, + ResizeNearestNeighborNopTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopInt8, + ClContextControlFixture, + ResizeNearestNeighborNopTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopUint8, + ClContextControlFixture, + ResizeNearestNeighborNopTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMin, + ClContextControlFixture, + ResizeNearestNeighborSqMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinInt8, + ClContextControlFixture, + ResizeNearestNeighborSqMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinUint8, + ClContextControlFixture, + ResizeNearestNeighborSqMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMin, + ClContextControlFixture, + ResizeNearestNeighborMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinInt8, + ClContextControlFixture, + ResizeNearestNeighborMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinUint8, + ClContextControlFixture, + ResizeNearestNeighborMinTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMag, + ClContextControlFixture, + ResizeNearestNeighborMagTest, + DataLayout::NCHW, 0.1f, 50, 0.1f, 50) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagInt8, + ClContextControlFixture, + ResizeNearestNeighborMagTest, + DataLayout::NCHW, 0.1f, 50, 0.1f, 50) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagUint8, + ClContextControlFixture, + ResizeNearestNeighborMagTest, + DataLayout::NCHW, 0.1f, 50, 0.1f, 50) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbour, + ClContextControlFixture, + HalfPixelCentersResizeNearestNeighbourTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbour, + ClContextControlFixture, + AlignCornersResizeNearestNeighbourTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8, + ClContextControlFixture, + HalfPixelCentersResizeNearestNeighbourTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourInt8, + ClContextControlFixture, + AlignCornersResizeNearestNeighbourTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8, + ClContextControlFixture, + HalfPixelCentersResizeNearestNeighbourTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourUint8, + ClContextControlFixture, + AlignCornersResizeNearestNeighbourTest, + DataLayout::NCHW) // Resize NearestNeighbor - NHWC -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopNhwc, - ResizeNearestNeighborNopTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopInt8Nhwc, - ResizeNearestNeighborNopTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8Nhwc, - ResizeNearestNeighborNopTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborNhwc, - SimpleResizeNearestNeighborTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborInt8Nhwc, - SimpleResizeNearestNeighborTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8Nhwc, - SimpleResizeNearestNeighborTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinNhwc, - ResizeNearestNeighborSqMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinInt8Nhwc, - ResizeNearestNeighborSqMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8Nhwc, - ResizeNearestNeighborSqMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinNhwc, - ResizeNearestNeighborMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinInt8Nhwc, - ResizeNearestNeighborMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8Nhwc, - ResizeNearestNeighborMinTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagNhwc, - ResizeNearestNeighborMagTest, - DataLayout::NHWC, 0.1f, 50, 0.1f, 50) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagInt8Nhwc, - ResizeNearestNeighborMagTest, - DataLayout::NHWC, 0.1f, 50, 0.1f, 50) -ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8Nhwc, - ResizeNearestNeighborMagTest, - DataLayout::NHWC, 0.1f, 50, 0.1f, 50) - -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourNhwc, - HalfPixelCentersResizeNearestNeighbourTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourNhwc, - AlignCornersResizeNearestNeighbourTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8Nhwc, - HalfPixelCentersResizeNearestNeighbourTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8Nhwc, - AlignCornersResizeNearestNeighbourTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8Nhwc, - HalfPixelCentersResizeNearestNeighbourTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8Nhwc, - AlignCornersResizeNearestNeighbourTest, - DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopNhwc, + ClContextControlFixture, + ResizeNearestNeighborNopTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopInt8Nhwc, + ClContextControlFixture, + ResizeNearestNeighborNopTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopUint8Nhwc, + ClContextControlFixture, + ResizeNearestNeighborNopTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborNhwc, + ClContextControlFixture, + SimpleResizeNearestNeighborTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborInt8Nhwc, + ClContextControlFixture, + SimpleResizeNearestNeighborTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborUint8Nhwc, + ClContextControlFixture, + SimpleResizeNearestNeighborTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinNhwc, + ClContextControlFixture, + ResizeNearestNeighborSqMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinInt8Nhwc, + ClContextControlFixture, + ResizeNearestNeighborSqMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinUint8Nhwc, + ClContextControlFixture, + ResizeNearestNeighborSqMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinNhwc, + ClContextControlFixture, + ResizeNearestNeighborMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinInt8Nhwc, + ClContextControlFixture, + ResizeNearestNeighborMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinUint8Nhwc, + ClContextControlFixture, + ResizeNearestNeighborMinTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagNhwc, + ClContextControlFixture, + ResizeNearestNeighborMagTest, + DataLayout::NHWC, 0.1f, 50, 0.1f, 50) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagInt8Nhwc, + ClContextControlFixture, + ResizeNearestNeighborMagTest, + DataLayout::NHWC, 0.1f, 50, 0.1f, 50) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagUint8Nhwc, + ClContextControlFixture, + ResizeNearestNeighborMagTest, + DataLayout::NHWC, 0.1f, 50, 0.1f, 50) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourNhwc, + ClContextControlFixture, + HalfPixelCentersResizeNearestNeighbourTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourNhwc, + ClContextControlFixture, + AlignCornersResizeNearestNeighbourTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8Nhwc, + ClContextControlFixture, + HalfPixelCentersResizeNearestNeighbourTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourInt8Nhwc, + ClContextControlFixture, + AlignCornersResizeNearestNeighbourTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8Nhwc, + ClContextControlFixture, + HalfPixelCentersResizeNearestNeighbourTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourUint8Nhwc, + ClContextControlFixture, + AlignCornersResizeNearestNeighbourTest, + DataLayout::NHWC) // Rsqrt -ARMNN_AUTO_TEST_CASE_WITH_THF(Rsqrt2d, Rsqrt2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Rsqrt3d, Rsqrt3dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(RsqrtZero, RsqrtZeroTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(RsqrtNegative, RsqrtNegativeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Rsqrt2d, ClContextControlFixture, Rsqrt2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Rsqrt3d, ClContextControlFixture, Rsqrt3dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RsqrtZero, ClContextControlFixture, RsqrtZeroTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RsqrtNegative, ClContextControlFixture, RsqrtNegativeTest) // Quantize -ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeSimpleUint8, QuantizeSimpleUint8Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(QuantizeClampUint8, QuantizeClampUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(QuantizeSimpleUint8, ClContextControlFixture, QuantizeSimpleUint8Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(QuantizeClampUint8, ClContextControlFixture, QuantizeClampUint8Test) // Dequantize -ARMNN_AUTO_TEST_CASE(DequantizeSimpleUint8, DequantizeSimpleUint8Test) -ARMNN_AUTO_TEST_CASE(DequantizeOffsetUint8, DequantizeOffsetUint8Test) -ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt16, DequantizeSimpleInt16Test) -ARMNN_AUTO_TEST_CASE(DequantizeSimpleUint8ToFp16, DequantizeSimpleUint8ToFp16Test) -ARMNN_AUTO_TEST_CASE(DequantizeSimpleInt16ToFp16, DequantizeSimpleInt16ToFp16Test) +ARMNN_AUTO_TEST_FIXTURE(DequantizeSimpleUint8, ClContextControlFixture, DequantizeSimpleUint8Test) +ARMNN_AUTO_TEST_FIXTURE(DequantizeOffsetUint8, ClContextControlFixture, DequantizeOffsetUint8Test) +ARMNN_AUTO_TEST_FIXTURE(DequantizeSimpleInt16, ClContextControlFixture, DequantizeSimpleInt16Test) +ARMNN_AUTO_TEST_FIXTURE(DequantizeSimpleUint8ToFp16, ClContextControlFixture, DequantizeSimpleUint8ToFp16Test) +ARMNN_AUTO_TEST_FIXTURE(DequantizeSimpleInt16ToFp16, ClContextControlFixture, DequantizeSimpleInt16ToFp16Test) // Transpose -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeFloat32, SimpleTransposeTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet1Test, TransposeValueSet1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet2Test, TransposeValueSet2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet3Test, TransposeValueSet3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymmS8, SimpleTransposeTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet1Test, TransposeValueSet1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet2Test, TransposeValueSet2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet3Test, TransposeValueSet3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymm8, SimpleTransposeTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet1Test, TransposeValueSet1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet2Test, TransposeValueSet2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet3Test, TransposeValueSet3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQSymm16, SimpleTransposeTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet1Test, TransposeValueSet1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet2Test, TransposeValueSet2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet3Test, TransposeValueSet3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SimpleTransposeFloat32, ClContextControlFixture, SimpleTransposeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeFloat32ValueSet1Test, ClContextControlFixture, TransposeValueSet1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeFloat32ValueSet2Test, ClContextControlFixture, TransposeValueSet2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeFloat32ValueSet3Test, ClContextControlFixture, TransposeValueSet3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SimpleTransposeQASymmS8, ClContextControlFixture, SimpleTransposeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeQASymmS8ValueSet1Test, ClContextControlFixture, TransposeValueSet1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeQASymmS8ValueSet2Test, ClContextControlFixture, TransposeValueSet2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeQASymmS8ValueSet3Test, ClContextControlFixture, TransposeValueSet3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SimpleTransposeQASymm8, ClContextControlFixture, SimpleTransposeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeQASymm8ValueSet1Test, ClContextControlFixture, TransposeValueSet1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeQASymm8ValueSet2Test, ClContextControlFixture, TransposeValueSet2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeQASymm8ValueSet3Test, ClContextControlFixture, TransposeValueSet3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + SimpleTransposeQSymm16, ClContextControlFixture, SimpleTransposeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeQSymm16ValueSet1Test, ClContextControlFixture, TransposeValueSet1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeQSymm16ValueSet2Test, ClContextControlFixture, TransposeValueSet2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + TransposeQSymm16ValueSet3Test, ClContextControlFixture, TransposeValueSet3Test) // TransposeConvolution2d -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNchw, - SimpleTransposeConvolution2dTest, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNhwc, - SimpleTransposeConvolution2dTest, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nchw, - SimpleTransposeConvolution2dTest, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nhwc, - SimpleTransposeConvolution2dTest, - true, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNchw, - SimpleTransposeConvolution2dTest, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNhwc, - SimpleTransposeConvolution2dTest, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nchw, - SimpleTransposeConvolution2dTest, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nhwc, - SimpleTransposeConvolution2dTest, - true, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNchw, - PaddedTransposeConvolution2dTest, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNhwc, - PaddedTransposeConvolution2dTest, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nchw, - PaddedTransposeConvolution2dTest, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nhwc, - PaddedTransposeConvolution2dTest, - true, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNchw, - PaddedTransposeConvolution2dTest, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNhwc, - PaddedTransposeConvolution2dTest, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nchw, - PaddedTransposeConvolution2dTest, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nhwc, - PaddedTransposeConvolution2dTest, - true, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNchw, - StridedTransposeConvolution2dTest, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNhwc, - StridedTransposeConvolution2dTest, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nchw, - StridedTransposeConvolution2dTest, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nhwc, - StridedTransposeConvolution2dTest, - true, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNchw, - StridedTransposeConvolution2dTest, - false, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNhwc, - StridedTransposeConvolution2dTest, - true, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nchw, - StridedTransposeConvolution2dTest, - true, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nhwc, - StridedTransposeConvolution2dTest, - true, - DataLayout::NHWC) - -ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNchw, - MultiChannelTransposeConvolution2dTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNhwc, - MultiChannelTransposeConvolution2dTest, - DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nchw, - MultiChannelTransposeConvolution2dTest, - DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nhwc, - MultiChannelTransposeConvolution2dTest, - DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleTransposeConvolution2dFloatNchw, + ClContextControlFixture, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleTransposeConvolution2dFloatNhwc, + ClContextControlFixture, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleTransposeConvolution2dUint8Nchw, + ClContextControlFixture, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleTransposeConvolution2dUint8Nhwc, + ClContextControlFixture, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNchw, + ClContextControlFixture, + SimpleTransposeConvolution2dTest, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNhwc, + ClContextControlFixture, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nchw, + ClContextControlFixture, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nhwc, + ClContextControlFixture, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PaddedTransposeConvolution2dFloatNchw, + ClContextControlFixture, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PaddedTransposeConvolution2dFloatNhwc, + ClContextControlFixture, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PaddedTransposeConvolution2dUint8Nchw, + ClContextControlFixture, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PaddedTransposeConvolution2dUint8Nhwc, + ClContextControlFixture, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNchw, + ClContextControlFixture, + PaddedTransposeConvolution2dTest, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNhwc, + ClContextControlFixture, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nchw, + ClContextControlFixture, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nhwc, + ClContextControlFixture, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedTransposeConvolution2dFloatNchw, + ClContextControlFixture, + StridedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedTransposeConvolution2dFloatNhwc, + ClContextControlFixture, + StridedTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedTransposeConvolution2dUint8Nchw, + ClContextControlFixture, + StridedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedTransposeConvolution2dUint8Nhwc, + ClContextControlFixture, + StridedTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNchw, + ClContextControlFixture, + StridedTransposeConvolution2dTest, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNhwc, + ClContextControlFixture, + StridedTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nchw, + ClContextControlFixture, + StridedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nhwc, + ClContextControlFixture, + StridedTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiChannelTransposeConvolution2dFloatNchw, + ClContextControlFixture, + MultiChannelTransposeConvolution2dTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiChannelTransposeConvolution2dFloatNhwc, + ClContextControlFixture, + MultiChannelTransposeConvolution2dTest, + DataLayout::NHWC) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nchw, + ClContextControlFixture, + MultiChannelTransposeConvolution2dTest, + DataLayout::NCHW) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nhwc, + ClContextControlFixture, + MultiChannelTransposeConvolution2dTest, + DataLayout::NHWC) // Abs -ARMNN_AUTO_TEST_CASE_WITH_THF(Abs2d, Abs2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Abs3d, Abs3dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Abs2d, ClContextControlFixture, Abs2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Abs3d, ClContextControlFixture, Abs3dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(AbsZero, AbsZeroTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AbsZero, ClContextControlFixture, AbsZeroTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Abs2dFloat16, Abs2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Abs3dFloat16, Abs3dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Abs2dFloat16, ClContextControlFixture, Abs2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Abs3dFloat16, ClContextControlFixture, Abs3dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(AbsZeroFloat16, AbsZeroTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AbsZeroFloat16, ClContextControlFixture, AbsZeroTest) // ArgMinMax -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinFloat32, ArgMinSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxFloat32, ArgMaxSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannel, ArgMinChannelTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannel, ArgMaxChannelTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeight, ArgMaxHeightTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidth, ArgMinWidthTest) - -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinQAsymm8, ArgMinSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxQAsymm8, ArgMaxSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelQAsymm8, ArgMinChannelTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelQAsymm8, ArgMaxChannelTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeightQAsymm8, ArgMaxHeightTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidthQAsymm8, ArgMinWidthTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinFloat32, ClContextControlFixture, ArgMinSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxFloat32, ClContextControlFixture, ArgMaxSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinChannel, ClContextControlFixture, ArgMinChannelTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxChannel, ClContextControlFixture, ArgMaxChannelTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxHeight, ClContextControlFixture, ArgMaxHeightTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinWidth, ClContextControlFixture, ArgMinWidthTest) + +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinQAsymm8, ClContextControlFixture, ArgMinSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxQAsymm8, ClContextControlFixture, ArgMaxSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinChannelQAsymm8, ClContextControlFixture, ArgMinChannelTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxChannelQAsymm8, ClContextControlFixture, ArgMaxChannelTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxHeightQAsymm8, ClContextControlFixture, ArgMaxHeightTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinWidthQAsymm8, ClContextControlFixture, ArgMinWidthTest) // Neg -ARMNN_AUTO_TEST_CASE_WITH_THF(Neg2d, Neg2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Neg3d, Neg3dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(NegZero, NegZeroTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(NegNegative, NegNegativeTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Neg2dFloat16, Neg2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Neg3dFloat16, Neg3dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Neg2d, ClContextControlFixture, Neg2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Neg3d, ClContextControlFixture, Neg3dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(NegZero, ClContextControlFixture, NegZeroTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(NegNegative, ClContextControlFixture, NegNegativeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Neg2dFloat16, ClContextControlFixture, Neg2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Neg3dFloat16, ClContextControlFixture, Neg3dTest) // Exp -ARMNN_AUTO_TEST_CASE_WITH_THF(Exp2d, Exp2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Exo3d, Exp3dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ExpZero, ExpZeroTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ExpNegative, ExpNegativeTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Exp2dFloat16, Exp2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(Exp3dFloat16, Exp3dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Exp2d, ClContextControlFixture, Exp2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Exo3d, ClContextControlFixture, Exp3dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ExpZero, ClContextControlFixture, ExpZeroTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ExpNegative, ClContextControlFixture, ExpNegativeTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Exp2dFloat16, ClContextControlFixture, Exp2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Exp3dFloat16, ClContextControlFixture, Exp3dTest) // Logical -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalNot, LogicalNotTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalNotInt, LogicalNotIntTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalNot, ClContextControlFixture, LogicalNotTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalNotInt, ClContextControlFixture, LogicalNotIntTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalAnd, LogicalAndTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalAndInt, LogicalAndIntTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalAndBroadcast1, LogicalAndBroadcast1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalAndBroadcast2, LogicalAndBroadcast2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalAndBroadcast3, LogicalAndBroadcast3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalAnd, ClContextControlFixture, LogicalAndTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalAndInt, ClContextControlFixture, LogicalAndIntTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalAndBroadcast1, ClContextControlFixture, LogicalAndBroadcast1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalAndBroadcast2, ClContextControlFixture, LogicalAndBroadcast2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalAndBroadcast3, ClContextControlFixture, LogicalAndBroadcast3Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalOr, LogicalOrTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalOrInt, LogicalOrIntTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalOrBroadcast1, LogicalOrBroadcast1Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalOrBroadcast2, LogicalOrBroadcast2Test) -ARMNN_AUTO_TEST_CASE_WITH_THF(LogicalOrBroadcast3, LogicalOrBroadcast3Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalOr, ClContextControlFixture, LogicalOrTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalOrInt, ClContextControlFixture, LogicalOrIntTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalOrBroadcast1, ClContextControlFixture, LogicalOrBroadcast1Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalOrBroadcast2, ClContextControlFixture, LogicalOrBroadcast2Test) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogicalOrBroadcast3, ClContextControlFixture, LogicalOrBroadcast3Test) // ReduceSum -ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceSumFloat32, ReduceSumSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceSumSingleAxisFloat32_1, ReduceSumSingleAxisTest1) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceSumSingleAxisFloat32_2, ReduceSumSingleAxisTest2) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceSumSingleAxisFloat32_3, ReduceSumSingleAxisTest3) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReduceSumFloat32, ClContextControlFixture, ReduceSumSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + ReduceSumSingleAxisFloat32_1, ClContextControlFixture, ReduceSumSingleAxisTest1) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + ReduceSumSingleAxisFloat32_2, ClContextControlFixture, ReduceSumSingleAxisTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + ReduceSumSingleAxisFloat32_3, ClContextControlFixture, ReduceSumSingleAxisTest3) // ReduceMax -ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMaxFloat32, ReduceMaxSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMaxNegativeAxisFloat32, ReduceMaxNegativeAxisTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMax2Float32, ReduceMaxSimpleTest2) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReduceMaxFloat32, ClContextControlFixture, ReduceMaxSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + ReduceMaxNegativeAxisFloat32, ClContextControlFixture, ReduceMaxNegativeAxisTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReduceMax2Float32, ClContextControlFixture, ReduceMaxSimpleTest2) // ReduceMin -ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMinFloat32, ReduceMinSimpleTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMinNegativeAxisFloat32, ReduceMinNegativeAxisTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReduceMinFloat32, ClContextControlFixture, ReduceMinSimpleTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF( + ReduceMinNegativeAxisFloat32, ClContextControlFixture, ReduceMinNegativeAxisTest) // Cast -ARMNN_AUTO_TEST_CASE_WITH_THF(CastInt32ToFloat, CastInt32ToFloat2dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(CastFloat16ToFloat32, CastFloat16ToFloat322dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(CastFloatToFloat16, CastFloat32ToFloat162dTest) -ARMNN_AUTO_TEST_CASE_WITH_THF(CastFloatToUInt8, CastFloat32ToUInt82dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(CastInt32ToFloat, ClContextControlFixture, CastInt32ToFloat2dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(CastFloat16ToFloat32, ClContextControlFixture, CastFloat16ToFloat322dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(CastFloatToFloat16, ClContextControlFixture, CastFloat32ToFloat162dTest) +ARMNN_AUTO_TEST_FIXTURE_WITH_THF(CastFloatToUInt8, ClContextControlFixture, CastFloat32ToUInt82dTest) #if defined(ARMNNREF_ENABLED) +TEST_CASE_FIXTURE(ClContextControlFixture, "ClContextControlFixture") {} + // The ARMNN_COMPARE_REF_AUTO_TEST_CASE and the ARMNN_COMPARE_REF_FIXTURE_TEST_CASE test units are not available // if the reference backend is not built @@ -1386,4 +1990,4 @@ ARMNN_COMPARE_REF_FIXTURE_TEST_CASE_WITH_THF(CompareEluActivationWithReference, #endif -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/ClMemCopyTests.cpp b/src/backends/cl/test/ClMemCopyTests.cpp index 1048e73c1b..98b873fb6f 100644 --- a/src/backends/cl/test/ClMemCopyTests.cpp +++ b/src/backends/cl/test/ClMemCopyTests.cpp @@ -11,44 +11,44 @@ #include #include -#include +#include -BOOST_AUTO_TEST_SUITE(ClMemCopy) - -BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndGpu) +TEST_SUITE("ClMemCopy") +{ +TEST_CASE("CopyBetweenCpuAndGpu") { LayerTestResult result = MemCopyTest(false); auto predResult = CompareTensors(result.m_ActualData, result.m_ExpectedData, result.m_ActualShape, result.m_ExpectedShape); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndCpu) +TEST_CASE("CopyBetweenGpuAndCpu") { LayerTestResult result = MemCopyTest(false); auto predResult = CompareTensors(result.m_ActualData, result.m_ExpectedData, result.m_ActualShape, result.m_ExpectedShape); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndGpuWithSubtensors) +TEST_CASE("CopyBetweenCpuAndGpuWithSubtensors") { LayerTestResult result = MemCopyTest(true); auto predResult = CompareTensors(result.m_ActualData, result.m_ExpectedData, result.m_ActualShape, result.m_ExpectedShape); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_CASE(CopyBetweenGpuAndCpuWithSubtensors) +TEST_CASE("CopyBetweenGpuAndCpuWithSubtensors") { LayerTestResult result = MemCopyTest(true); auto predResult = CompareTensors(result.m_ActualData, result.m_ExpectedData, result.m_ActualShape, result.m_ExpectedShape); - BOOST_TEST(predResult.m_Result, predResult.m_Message.str()); + CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str()); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/ClOptimizedNetworkTests.cpp b/src/backends/cl/test/ClOptimizedNetworkTests.cpp index a41c5f87e9..d91e9b4f8d 100644 --- a/src/backends/cl/test/ClOptimizedNetworkTests.cpp +++ b/src/backends/cl/test/ClOptimizedNetworkTests.cpp @@ -14,12 +14,11 @@ #include +#include -#include - -BOOST_AUTO_TEST_SUITE(ClOptimizedNetwork) - -BOOST_AUTO_TEST_CASE(OptimizeValidateGpuDeviceSupportLayerNoFallback) +TEST_SUITE("ClOptimizedNetwork") +{ +TEST_CASE("OptimizeValidateGpuDeviceSupportLayerNoFallback") { // build up the structure of the network armnn::INetworkPtr net(armnn::INetwork::Create()); @@ -35,7 +34,7 @@ BOOST_AUTO_TEST_CASE(OptimizeValidateGpuDeviceSupportLayerNoFallback) std::vector backends = { armnn::Compute::GpuAcc }; armnn::IOptimizedNetworkPtr optNet = armnn::Optimize(*net, backends, runtime->GetDeviceSpec()); - BOOST_CHECK(optNet); + CHECK(optNet); // validate workloads armnn::ClWorkloadFactory fact = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager()); @@ -43,13 +42,13 @@ BOOST_AUTO_TEST_CASE(OptimizeValidateGpuDeviceSupportLayerNoFallback) const armnn::Graph& theGraph = GetGraphForTesting(optNet.get()); for (auto&& layer : theGraph) { - BOOST_CHECK(layer->GetBackendId() == armnn::Compute::GpuAcc); - BOOST_CHECK_NO_THROW( + CHECK(layer->GetBackendId() == armnn::Compute::GpuAcc); + CHECK_NOTHROW( layer->CreateWorkload(fact)); } } -BOOST_AUTO_TEST_CASE(FP16TurboModeTestOnGpuAcc) +TEST_CASE("FP16TurboModeTestOnGpuAcc") { // Test to check when Fp16 Turbo mode set // it converts the Fp32 network to Fp16 Network @@ -96,17 +95,17 @@ BOOST_AUTO_TEST_CASE(FP16TurboModeTestOnGpuAcc) const armnn::Graph& graph = GetGraphForTesting(optimizedNet.get()); // Tests that all layers are present in the graph. - BOOST_TEST(graph.GetNumLayers() == 5); + CHECK(graph.GetNumLayers() == 5); // Tests that the vertices exist and have correct names. - BOOST_TEST(GraphHasNamedLayer(graph, "input layer")); - BOOST_TEST(GraphHasNamedLayer(graph, "convert_fp32_to_fp16-0-input layer")); - BOOST_TEST(GraphHasNamedLayer(graph, "activation layer")); - BOOST_TEST(GraphHasNamedLayer(graph, "convert_fp16_to_fp32-0-output layer")); - BOOST_TEST(GraphHasNamedLayer(graph, "output layer")); + CHECK(GraphHasNamedLayer(graph, "input layer")); + CHECK(GraphHasNamedLayer(graph, "convert_fp32_to_fp16-0-input layer")); + CHECK(GraphHasNamedLayer(graph, "activation layer")); + CHECK(GraphHasNamedLayer(graph, "convert_fp16_to_fp32-0-output layer")); + CHECK(GraphHasNamedLayer(graph, "output layer")); } -BOOST_AUTO_TEST_CASE(FastMathEnabledTestOnGpuAcc) +TEST_CASE("FastMathEnabledTestOnGpuAcc") { armnn::INetworkPtr net(armnn::INetwork::Create()); @@ -127,16 +126,16 @@ BOOST_AUTO_TEST_CASE(FastMathEnabledTestOnGpuAcc) armnn::IOptimizedNetworkPtr optimizedNet = armnn::Optimize( *net, backends, runtime->GetDeviceSpec(), optimizerOptions); - BOOST_CHECK(optimizedNet); + CHECK(optimizedNet); auto modelOptionsOut = GetModelOptionsForTesting(optimizedNet.get()); - BOOST_TEST(modelOptionsOut.size() == 1); - BOOST_TEST(modelOptionsOut[0].GetOption(0).GetName() == "FastMathEnabled"); - BOOST_TEST(modelOptionsOut[0].GetOption(0).GetValue().AsBool() == true); + CHECK(modelOptionsOut.size() == 1); + CHECK(modelOptionsOut[0].GetOption(0).GetName() == "FastMathEnabled"); + CHECK(modelOptionsOut[0].GetOption(0).GetValue().AsBool() == true); } -BOOST_AUTO_TEST_CASE(CheckMLGOTuningFile) +TEST_CASE("CheckMLGOTuningFile") { class ClBackendContextTestClass : public armnn::ClBackendContext { @@ -202,7 +201,7 @@ BOOST_AUTO_TEST_CASE(CheckMLGOTuningFile) catch (std::exception &e) { std::cerr << "Unable to write to file at location [" << validFile.c_str() << "] : " << e.what() << std::endl; - BOOST_TEST(false); + CHECK(false); } armnn::IRuntime::CreationOptions creationOptions1; @@ -216,7 +215,7 @@ BOOST_AUTO_TEST_CASE(CheckMLGOTuningFile) creationOptions1.m_BackendOptions.emplace_back(validOptions); ClBackendContextTestClass clBackendContext1(creationOptions1); - BOOST_TEST(clBackendContext1.call_reload_from_file()); + CHECK(clBackendContext1.call_reload_from_file()); armnn::BackendOptions invalidOptions { @@ -229,7 +228,7 @@ BOOST_AUTO_TEST_CASE(CheckMLGOTuningFile) armnn::IRuntime::CreationOptions creationOptions2; creationOptions2.m_BackendOptions.emplace_back(invalidOptions); ClBackendContextTestClass clBackendContext2(creationOptions2); - BOOST_TEST(clBackendContext2.call_reload_from_file() == false); + CHECK(clBackendContext2.call_reload_from_file() == false); armnn::BackendOptions invalidPathOptions { @@ -242,7 +241,7 @@ BOOST_AUTO_TEST_CASE(CheckMLGOTuningFile) armnn::IRuntime::CreationOptions creationOptions3; creationOptions3.m_BackendOptions.emplace_back(invalidPathOptions); ClBackendContextTestClass clBackendContext3(creationOptions3); - BOOST_TEST(clBackendContext3.call_reload_from_file() == false); + CHECK(clBackendContext3.call_reload_from_file() == false); } -BOOST_AUTO_TEST_SUITE_END(); +} diff --git a/src/backends/cl/test/ClRuntimeTests.cpp b/src/backends/cl/test/ClRuntimeTests.cpp index 33e86b6fc4..db01fa7dcf 100644 --- a/src/backends/cl/test/ClRuntimeTests.cpp +++ b/src/backends/cl/test/ClRuntimeTests.cpp @@ -11,15 +11,15 @@ #include #include -#include +#include #ifdef WITH_VALGRIND #include #endif -BOOST_AUTO_TEST_SUITE(ClRuntime) - -BOOST_AUTO_TEST_CASE(RuntimeValidateGpuDeviceSupportLayerNoFallback) +TEST_SUITE("ClRuntime") +{ +TEST_CASE("RuntimeValidateGpuDeviceSupportLayerNoFallback") { // build up the structure of the network armnn::INetworkPtr net(armnn::INetwork::Create()); @@ -35,17 +35,17 @@ BOOST_AUTO_TEST_CASE(RuntimeValidateGpuDeviceSupportLayerNoFallback) std::vector backends = { armnn::Compute::GpuAcc }; armnn::IOptimizedNetworkPtr optNet = armnn::Optimize(*net, backends, runtime->GetDeviceSpec()); - BOOST_CHECK(optNet); + CHECK(optNet); // Load it into the runtime. It should success. armnn::NetworkId netId; - BOOST_TEST(runtime->LoadNetwork(netId, std::move(optNet)) == armnn::Status::Success); + CHECK(runtime->LoadNetwork(netId, std::move(optNet)) == armnn::Status::Success); } #ifdef ARMNN_LEAK_CHECKING_ENABLED -BOOST_AUTO_TEST_CASE(RuntimeMemoryLeaksGpuAcc) +TEST_CASE("RuntimeMemoryLeaksGpuAcc") { - BOOST_TEST(ARMNN_LEAK_CHECKER_IS_ACTIVE()); + CHECK(ARMNN_LEAK_CHECKER_IS_ACTIVE()); armnn::IRuntime::CreationOptions options; armnn::RuntimeImpl runtime(options); armnn::RuntimeLoadedNetworksReserve(&runtime); @@ -59,21 +59,21 @@ BOOST_AUTO_TEST_CASE(RuntimeMemoryLeaksGpuAcc) { ARMNN_SCOPED_LEAK_CHECKER("LoadAndUnloadNetworkGpuAcc"); - BOOST_TEST(ARMNN_NO_LEAKS_IN_SCOPE()); + CHECK(ARMNN_NO_LEAKS_IN_SCOPE()); // In the second run we check for all remaining memory // in use after the network was unloaded. If there is any // then it will be treated as a memory leak. CreateAndDropDummyNetwork(backends, runtime); - BOOST_TEST(ARMNN_NO_LEAKS_IN_SCOPE()); - BOOST_TEST(ARMNN_BYTES_LEAKED_IN_SCOPE() == 0); - BOOST_TEST(ARMNN_OBJECTS_LEAKED_IN_SCOPE() == 0); + CHECK(ARMNN_NO_LEAKS_IN_SCOPE()); + CHECK(ARMNN_BYTES_LEAKED_IN_SCOPE() == 0); + CHECK(ARMNN_OBJECTS_LEAKED_IN_SCOPE() == 0); } } #endif // Note: this part of the code is due to be removed when we fully trust the gperftools based results. #if defined(WITH_VALGRIND) -BOOST_AUTO_TEST_CASE(RuntimeMemoryUsage) +TEST_CASE("RuntimeMemoryUsage") { // From documentation: @@ -135,12 +135,12 @@ BOOST_AUTO_TEST_CASE(RuntimeMemoryUsage) VALGRIND_COUNT_LEAKS(leakedAfter, dubious, reachableAfter, suppressed); // If we're not running under Valgrind, these vars will have been initialised to 0, so this will always pass. - BOOST_TEST(leakedBefore == leakedAfter); + CHECK(leakedBefore == leakedAfter); // Add resonable threshold after and before running valgrind with the ACL clear cache function. // TODO Threshold set to 80k until the root cause of the memory leakage is found and fixed. Revert threshold // value to 1024 when fixed. - BOOST_TEST(static_cast(reachableAfter) - static_cast(reachableBefore) < 81920); + CHECK(static_cast(reachableAfter) - static_cast(reachableBefore) < 81920); // These are needed because VALGRIND_COUNT_LEAKS is a macro that assigns to the parameters // so they are assigned to, but still considered unused, causing a warning. @@ -149,9 +149,9 @@ BOOST_AUTO_TEST_CASE(RuntimeMemoryUsage) } #endif -BOOST_AUTO_TEST_CASE(ProfilingPostOptimisationStructureGpuAcc) +TEST_CASE("ProfilingPostOptimisationStructureGpuAcc") { VerifyPostOptimisationStructureTestImpl(armnn::Compute::GpuAcc); } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/Fp16SupportTest.cpp b/src/backends/cl/test/Fp16SupportTest.cpp index 5afafcb783..1974d4d856 100644 --- a/src/backends/cl/test/Fp16SupportTest.cpp +++ b/src/backends/cl/test/Fp16SupportTest.cpp @@ -13,15 +13,15 @@ #include #include -#include +#include #include using namespace armnn; -BOOST_AUTO_TEST_SUITE(Fp16Support) - -BOOST_AUTO_TEST_CASE(Fp16DataTypeSupport) +TEST_SUITE("Fp16Support") +{ +TEST_CASE("Fp16DataTypeSupport") { Graph graph; @@ -40,12 +40,12 @@ BOOST_AUTO_TEST_CASE(Fp16DataTypeSupport) inputLayer2->GetOutputSlot().SetTensorInfo(fp16TensorInfo); additionLayer->GetOutputSlot().SetTensorInfo(fp16TensorInfo); - BOOST_CHECK(inputLayer1->GetOutputSlot(0).GetTensorInfo().GetDataType() == armnn::DataType::Float16); - BOOST_CHECK(inputLayer2->GetOutputSlot(0).GetTensorInfo().GetDataType() == armnn::DataType::Float16); - BOOST_CHECK(additionLayer->GetOutputSlot(0).GetTensorInfo().GetDataType() == armnn::DataType::Float16); + CHECK(inputLayer1->GetOutputSlot(0).GetTensorInfo().GetDataType() == armnn::DataType::Float16); + CHECK(inputLayer2->GetOutputSlot(0).GetTensorInfo().GetDataType() == armnn::DataType::Float16); + CHECK(additionLayer->GetOutputSlot(0).GetTensorInfo().GetDataType() == armnn::DataType::Float16); } -BOOST_AUTO_TEST_CASE(Fp16AdditionTest) +TEST_CASE("Fp16AdditionTest") { using namespace half_float::literal; // Create runtime in which test will run @@ -104,7 +104,7 @@ BOOST_AUTO_TEST_CASE(Fp16AdditionTest) runtime->EnqueueWorkload(netId, inputTensors, outputTensors); // Checks the results. - BOOST_TEST(outputData == std::vector({ 101.0_h, 202.0_h, 303.0_h, 404.0_h})); // Add + CHECK(outputData == std::vector({ 101.0_h, 202.0_h, 303.0_h, 404.0_h})); // Add } -BOOST_AUTO_TEST_SUITE_END() +} diff --git a/src/backends/cl/test/OpenClTimerTest.cpp b/src/backends/cl/test/OpenClTimerTest.cpp index 7c8e27710b..0da1db73b8 100644 --- a/src/backends/cl/test/OpenClTimerTest.cpp +++ b/src/backends/cl/test/OpenClTimerTest.cpp @@ -21,7 +21,7 @@ #include -#include +#include #include @@ -38,11 +38,10 @@ struct OpenClFixture ClContextControl m_ClContextControl; }; -BOOST_FIXTURE_TEST_SUITE(OpenClTimerBatchNorm, OpenClFixture) -using FactoryType = ClWorkloadFactory; - -BOOST_AUTO_TEST_CASE(OpenClTimerBatchNorm) +TEST_CASE_FIXTURE(OpenClFixture, "OpenClTimerBatchNorm") { +//using FactoryType = ClWorkloadFactory; + auto memoryManager = ClWorkloadFactoryHelper::GetMemoryManager(); ClWorkloadFactory workloadFactory = ClWorkloadFactoryHelper::GetFactory(memoryManager); @@ -109,7 +108,7 @@ BOOST_AUTO_TEST_CASE(OpenClTimerBatchNorm) OpenClTimer openClTimer; - BOOST_CHECK_EQUAL(openClTimer.GetName(), "OpenClKernelTimer"); + CHECK_EQ(openClTimer.GetName(), "OpenClKernelTimer"); //Start the timer openClTimer.Start(); @@ -120,15 +119,13 @@ BOOST_AUTO_TEST_CASE(OpenClTimerBatchNorm) //Stop the timer openClTimer.Stop(); - BOOST_CHECK_EQUAL(openClTimer.GetMeasurements().size(), 1); + CHECK_EQ(openClTimer.GetMeasurements().size(), 1); - BOOST_CHECK_EQUAL(openClTimer.GetMeasurements().front().m_Name, + CHECK_EQ(openClTimer.GetMeasurements().front().m_Name, "OpenClKernelTimer/0: batchnormalization_layer_nchw GWS[1,3,2]"); - BOOST_CHECK(openClTimer.GetMeasurements().front().m_Value > 0); + CHECK(openClTimer.GetMeasurements().front().m_Value > 0); } -BOOST_AUTO_TEST_SUITE_END() - #endif //aarch64 or x86_64 -- cgit v1.2.1