IVGCVSW-5963 'Move unit tests to new framework'
* Used doctest in ArmNN unit tests
Signed-off-by: Sadik Armagan <sadik.armagan@arm.com>
Change-Id: Ia9cf5fc72775878885c5f864abf2c56b3a935f1a
diff --git a/src/backends/cl/test/ClContextSerializerTests.cpp b/src/backends/cl/test/ClContextSerializerTests.cpp
index 1fc0fb9..1135e11 100644
--- a/src/backends/cl/test/ClContextSerializerTests.cpp
+++ b/src/backends/cl/test/ClContextSerializerTests.cpp
@@ -7,7 +7,7 @@
#include <cl/test/ClContextControlFixture.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
#include <fstream>
@@ -66,9 +66,7 @@
} // 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 @@
*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<char> 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<uint8_t> outputData1(5);
@@ -128,11 +126,8 @@
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 7602cbb..4e40328 100644
--- a/src/backends/cl/test/ClCreateWorkloadTests.cpp
+++ b/src/backends/cl/test/ClCreateWorkloadTests.cpp
@@ -21,14 +21,16 @@
#include <cl/workloads/ClWorkloads.hpp>
#include <cl/workloads/ClWorkloadUtils.hpp>
+#include <doctest/doctest.h>
+
armnn::PredicateResult CompareIClTensorHandleShape(IClTensorHandle* tensorHandle,
std::initializer_list<unsigned int> expectedDimensions)
{
return CompareTensorHandleShape<IClTensorHandle>(tensorHandle, expectedDimensions);
}
-BOOST_FIXTURE_TEST_SUITE(CreateWorkloadCl, ClContextControlFixture)
-
+TEST_SUITE("CreateWorkloadCl")
+{
template <armnn::DataType DataType>
static void ClCreateActivationWorkloadTest()
{
@@ -44,18 +46,18 @@
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateActivationFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateActivationFloat16Workload")
{
ClCreateActivationWorkloadTest<armnn::DataType::Float16>();
}
@@ -78,14 +80,14 @@
auto inputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<ClAdditionWorkload,
AdditionQueueDescriptor,
@@ -93,7 +95,7 @@
armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateAdditionFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateAdditionFloat16Workload")
{
ClCreateElementwiseWorkloadTest<ClAdditionWorkload,
AdditionQueueDescriptor,
@@ -101,7 +103,7 @@
armnn::DataType::Float16>();
}
-BOOST_AUTO_TEST_CASE(CreateSubtractionFloatWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSubtractionFloatWorkload")
{
ClCreateElementwiseWorkloadTest<ClSubtractionWorkload,
SubtractionQueueDescriptor,
@@ -109,7 +111,7 @@
armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateSubtractionFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSubtractionFloat16Workload")
{
ClCreateElementwiseWorkloadTest<ClSubtractionWorkload,
SubtractionQueueDescriptor,
@@ -117,7 +119,7 @@
armnn::DataType::Float16>();
}
-BOOST_AUTO_TEST_CASE(CreateMultiplicationFloatWorkloadTest)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMultiplicationFloatWorkloadTest")
{
ClCreateElementwiseWorkloadTest<ClMultiplicationWorkload,
MultiplicationQueueDescriptor,
@@ -125,7 +127,7 @@
armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat16WorkloadTest)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMultiplicationFloat16WorkloadTest")
{
ClCreateElementwiseWorkloadTest<ClMultiplicationWorkload,
MultiplicationQueueDescriptor,
@@ -133,7 +135,7 @@
armnn::DataType::Float16>();
}
-BOOST_AUTO_TEST_CASE(CreateMultiplicationUint8WorkloadTest)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMultiplicationUint8WorkloadTest")
{
ClCreateElementwiseWorkloadTest<ClMultiplicationWorkload,
MultiplicationQueueDescriptor,
@@ -141,7 +143,7 @@
armnn::DataType::QAsymmU8>();
}
-BOOST_AUTO_TEST_CASE(CreateDivisionFloatWorkloadTest)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDivisionFloatWorkloadTest")
{
ClCreateElementwiseWorkloadTest<ClDivisionWorkload,
DivisionQueueDescriptor,
@@ -149,7 +151,7 @@
armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateDivisionFloat16WorkloadTest)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDivisionFloat16WorkloadTest")
{
ClCreateElementwiseWorkloadTest<ClDivisionWorkload,
DivisionQueueDescriptor,
@@ -174,13 +176,13 @@
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<ClRsqrtWorkload, RsqrtQueueDescriptor, armnn::DataType::Float32>(
UnaryOperation::Rsqrt);
@@ -206,43 +208,43 @@
{
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<ClBatchNormalizationFloatWorkload,
armnn::DataType::Float32>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat16NchwWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateBatchNormalizationFloat16NchwWorkload")
{
ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
armnn::DataType::Float16>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloatNhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateBatchNormalizationFloatNhwcWorkload")
{
ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
armnn::DataType::Float32>(DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(CreateBatchNormalizationNhwcFloat16NhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateBatchNormalizationNhwcFloat16NhwcWorkload")
{
ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
armnn::DataType::Float16>(DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(CreateConvertFp16ToFp32Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvertFp16ToFp32Workload")
{
Graph graph;
ClWorkloadFactory factory =
@@ -254,14 +256,14 @@
auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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 @@
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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 <typename Convolution2dWorkloadType, typename armnn::DataType DataType>
@@ -301,31 +303,31 @@
Convolution2dQueueDescriptor queueDescriptor = workload->GetData();
auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatNhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dFloatNhwcWorkload")
{
ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16NchwWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dFloat16NchwWorkload")
{
ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16NhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dFloat16NhwcWorkload")
{
ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(CreateConvolution2dFastMathEnabledWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConvolution2dFastMathEnabledWorkload")
{
Graph graph;
@@ -353,7 +355,7 @@
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 @@
// 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<ClConvolution2dWorkload>(queueDescriptor,
workloadInfo,
@@ -442,7 +444,7 @@
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 <typename DepthwiseConvolutionWorkloadType, typename armnn::DataType DataType>
@@ -465,11 +467,11 @@
TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 })
: std::initializer_list<unsigned int>({ 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<ClDepthwiseConvolutionWorkload, DataType::Float32>(DataLayout::NHWC);
}
@@ -488,22 +490,22 @@
auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<ClConvolution2dWorkload, armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDirectConvolution2dFloat16Workload")
{
ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>();
}
-BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dUint8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateDirectConvolution2dUint8Workload")
{
ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::QAsymmU8>();
}
@@ -523,18 +525,18 @@
auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<ClFullyConnectedWorkload, armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloat16WorkloadTest)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateFullyConnectedFloat16WorkloadTest")
{
ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float16>();
}
@@ -558,26 +560,26 @@
TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 5, 5, 1})
: std::initializer_list<unsigned int>({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<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateNormalizationFloat16NchwWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateNormalizationFloat16NchwWorkload")
{
ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateNormalizationFloat32NhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateNormalizationFloat32NhwcWorkload")
{
ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(CreateNormalizationFloat16NhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateNormalizationFloat16NhwcWorkload")
{
ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
}
@@ -601,26 +603,26 @@
auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<armnn::DataType::Float32>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreatePooling2dFloatNhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePooling2dFloatNhwcWorkload")
{
ClPooling2dWorkloadTest<armnn::DataType::Float32>(DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16NchwWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePooling2dFloat16NchwWorkload")
{
ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16NhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreatePooling2dFloat16NhwcWorkload")
{
ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NHWC);
}
@@ -647,22 +649,22 @@
auto alphaHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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 @@
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateReshapeFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateReshapeFloat16Workload")
{
ClCreateReshapeWorkloadTest<armnn::DataType::Float16>();
}
-BOOST_AUTO_TEST_CASE(CreateReshapeUint8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateReshapeUint8Workload")
{
ClCreateReshapeWorkloadTest<armnn::DataType::QAsymmU8>();
}
@@ -729,28 +731,28 @@
}
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<ClSoftmaxWorkload, armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat16WorkloadTest)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSoftmaxFloat16WorkloadTest")
{
ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float16>();
}
-BOOST_AUTO_TEST_CASE(CreateSoftmaxQAsymmU8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSoftmaxQAsymmU8Workload")
{
ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmU8>();
}
-BOOST_AUTO_TEST_CASE(CreateSoftmaxQAsymmS8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSoftmaxQAsymmS8Workload")
{
ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmS8>();
}
@@ -768,27 +770,27 @@
SplitterQueueDescriptor queueDescriptor = workload->GetData();
auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(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<IClTensorHandle*>(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<IClTensorHandle*>(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<IClTensorHandle*>(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<armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateSplitterFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSplitterFloat16Workload")
{
ClSplitterWorkloadTest<armnn::DataType::Float16>();
}
@@ -819,35 +821,35 @@
armnn::ClSubTensorHandle* mIn0 = dynamic_cast<armnn::ClSubTensorHandle*>(wlConcat->GetData().m_Inputs[0]);
armnn::ClSubTensorHandle* mIn1 = dynamic_cast<armnn::ClSubTensorHandle*>(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<armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateSplitterConcatFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSplitterConcatFloat16Workload")
{
ClSplitterConcatTest<armnn::DataType::Float16>();
}
-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 @@
armnn::ClSubTensorHandle* activ1_1Im = dynamic_cast<armnn::ClSubTensorHandle*>(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 @@
TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 5, 20, 50, 67 })
: std::initializer_list<unsigned int>({ 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<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloatNhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateL2NormalizationFloatNhwcWorkload")
{
ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloat16NchwWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateL2NormalizationFloat16NchwWorkload")
{
ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateL2NormalizationFloat16NhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateL2NormalizationFloat16NhwcWorkload")
{
ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
}
@@ -961,12 +963,12 @@
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<ClLogSoftmaxWorkload, armnn::DataType::Float32>();
}
@@ -984,12 +986,12 @@
auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<ClLstmFloatWorkload>();
}
@@ -1013,44 +1015,44 @@
{
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<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateResizeFloat16NchwWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeFloat16NchwWorkload")
{
ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateResizeUint8NchwWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeUint8NchwWorkload")
{
ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(CreateResizeFloat32NhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeFloat32NhwcWorkload")
{
ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(CreateResizeFloat16NhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeFloat16NhwcWorkload")
{
ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(CreateResizeUint8NhwcWorkload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateResizeUint8NhwcWorkload")
{
ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
}
@@ -1071,22 +1073,22 @@
// 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<ClMeanWorkload, armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateMeanFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMeanFloat16Workload")
{
ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float16>();
}
-BOOST_AUTO_TEST_CASE(CreateMeanUint8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateMeanUint8Workload")
{
ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::QAsymmU8>();
}
@@ -1107,39 +1109,39 @@
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<ClConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
}
-BOOST_AUTO_TEST_CASE(CreateConcatDim1Float32Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim1Float32Workload")
{
ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
}
-BOOST_AUTO_TEST_CASE(CreateConcatDim3Float32Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim3Float32Workload")
{
ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
}
-BOOST_AUTO_TEST_CASE(CreateConcatDim0Uint8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim0Uint8Workload")
{
ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
}
-BOOST_AUTO_TEST_CASE(CreateConcatDim1Uint8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim1Uint8Workload")
{
ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
}
-BOOST_AUTO_TEST_CASE(CreateConcatDim3Uint8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateConcatDim3Uint8Workload")
{
ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
}
@@ -1158,27 +1160,27 @@
auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(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<ClSpaceToDepthWorkload, armnn::DataType::Float32>();
}
-BOOST_AUTO_TEST_CASE(CreateSpaceToDepthFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSpaceToDepthFloat16Workload")
{
ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float16>();
}
-BOOST_AUTO_TEST_CASE(CreateSpaceToDepthQAsymm8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSpaceToDepthQAsymm8Workload")
{
ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
}
-BOOST_AUTO_TEST_CASE(CreateSpaceToDepthQSymm16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateSpaceToDepthQSymm16Workload")
{
ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
}
@@ -1206,24 +1208,24 @@
{
auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(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<IClTensorHandle*>(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<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
}
-BOOST_AUTO_TEST_CASE(CreateStackFloat16Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateStackFloat16Workload")
{
ClCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
}
-BOOST_AUTO_TEST_CASE(CreateStackUint8Workload)
+TEST_CASE_FIXTURE(ClContextControlFixture, "CreateStackUint8Workload")
{
ClCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
}
@@ -1239,19 +1241,19 @@
QLstmQueueDescriptor queueDescriptor = workload->GetData();
IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(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<IAclTensorHandle*>(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<IAclTensorHandle*>(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<ClQLstmWorkload>();
}
@@ -1270,29 +1272,29 @@
QuantizedLstmQueueDescriptor queueDescriptor = workload->GetData();
IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(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<IAclTensorHandle*>(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<IAclTensorHandle*>(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<IAclTensorHandle*>(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<IAclTensorHandle*>(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<ClQuantizedLstmWorkload>();
}
-BOOST_AUTO_TEST_SUITE_END()
+}
diff --git a/src/backends/cl/test/ClEndToEndTests.cpp b/src/backends/cl/test/ClEndToEndTests.cpp
index edee368..9e0137e 100644
--- a/src/backends/cl/test/ClEndToEndTests.cpp
+++ b/src/backends/cl/test/ClEndToEndTests.cpp
@@ -21,14 +21,14 @@
#include <backendsCommon/test/SplitterEndToEndTestImpl.hpp>
#include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
-BOOST_AUTO_TEST_SUITE(ClEndToEnd)
-
-std::vector<armnn::BackendId> defaultBackends = {armnn::Compute::GpuAcc};
+TEST_SUITE("ClEndToEnd")
+{
+std::vector<armnn::BackendId> clDefaultBackends = {armnn::Compute::GpuAcc};
// Abs
-BOOST_AUTO_TEST_CASE(ClAbsEndToEndTestFloat32)
+TEST_CASE("ClAbsEndToEndTestFloat32")
{
std::vector<float> expectedOutput =
{
@@ -36,482 +36,482 @@
3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
};
- ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
+ ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(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<armnn::DataType::Float32>(defaultBackends);
+ ConcatDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim0Uint8Test)
+TEST_CASE("ClConcatEndToEndDim0Uint8Test")
{
- ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Test)
+TEST_CASE("ClConcatEndToEndDim1Test")
{
- ConcatDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ConcatDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Uint8Test)
+TEST_CASE("ClConcatEndToEndDim1Uint8Test")
{
- ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Test)
+TEST_CASE("ClConcatEndToEndDim3Test")
{
- ConcatDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ConcatDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Uint8Test)
+TEST_CASE("ClConcatEndToEndDim3Uint8Test")
{
- ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
// DepthToSpace
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat32)
+TEST_CASE("DephtToSpaceEndToEndNchwFloat32")
{
- DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
+ DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat16)
+TEST_CASE("DephtToSpaceEndToEndNchwFloat16")
{
- DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NCHW);
+ DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwUint8)
+TEST_CASE("DephtToSpaceEndToEndNchwUint8")
{
- DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW);
+ DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwInt16)
+TEST_CASE("DephtToSpaceEndToEndNchwInt16")
{
- DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW);
+ DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat32)
+TEST_CASE("DephtToSpaceEndToEndNhwcFloat32")
{
- DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
+ DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat16)
+TEST_CASE("DephtToSpaceEndToEndNhwcFloat16")
{
- DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
+ DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcUint8)
+TEST_CASE("DephtToSpaceEndToEndNhwcUint8")
{
- DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC);
+ DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcInt16)
+TEST_CASE("DephtToSpaceEndToEndNhwcInt16")
{
- DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC);
+ DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NHWC);
}
// Dequantize
-BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest)
+TEST_CASE("DequantizeEndToEndSimpleTest")
{
- DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
+ DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(DequantizeEndToEndOffsetTest)
+TEST_CASE("DequantizeEndToEndOffsetTest")
{
- DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(defaultBackends);
+ DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClStridedSliceInvalidSliceEndToEndTest)
+TEST_CASE("ClStridedSliceInvalidSliceEndToEndTest")
{
- StridedSliceInvalidSliceEndToEndTest(defaultBackends);
+ StridedSliceInvalidSliceEndToEndTest(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClEluEndToEndTestFloat32)
+TEST_CASE("ClEluEndToEndTestFloat32")
{
- EluEndToEndTest<armnn::DataType::Float32>(defaultBackends);
+ EluEndToEndTest<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClEluEndToEndTestFloat16)
+TEST_CASE("ClEluEndToEndTestFloat16")
{
- EluEndToEndTest<armnn::DataType::Float16>(defaultBackends);
+ EluEndToEndTest<armnn::DataType::Float16>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndTest)
+TEST_CASE("ClGreaterSimpleEndToEndTest")
{
const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0 });
- ComparisonSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
+ ComparisonSimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
ComparisonOperation::Greater,
expectedOutput);
}
-BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndUint8Test)
+TEST_CASE("ClGreaterSimpleEndToEndUint8Test")
{
const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0 });
- ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
+ ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends,
ComparisonOperation::Greater,
expectedOutput);
}
-BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndTest)
+TEST_CASE("ClGreaterBroadcastEndToEndTest")
{
const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
1, 1, 1, 1, 1, 1 });
- ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends,
+ ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
ComparisonOperation::Greater,
expectedOutput);
}
-BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndUint8Test)
+TEST_CASE("ClGreaterBroadcastEndToEndUint8Test")
{
const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
1, 1, 1, 1, 1, 1 });
- ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
+ ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends,
ComparisonOperation::Greater,
expectedOutput);
}
// HardSwish
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestFloat32)
+TEST_CASE("ClHardSwishEndToEndTestFloat32")
{
- HardSwishEndToEndTest<armnn::DataType::Float32>(defaultBackends);
+ HardSwishEndToEndTest<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestFloat16)
+TEST_CASE("ClHardSwishEndToEndTestFloat16")
{
- HardSwishEndToEndTest<armnn::DataType::Float16>(defaultBackends);
+ HardSwishEndToEndTest<armnn::DataType::Float16>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQAsymmS8)
+TEST_CASE("ClHardSwishEndToEndTestQAsymmS8")
{
- HardSwishEndToEndTest<armnn::DataType::QAsymmS8>(defaultBackends);
+ HardSwishEndToEndTest<armnn::DataType::QAsymmS8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQAsymmU8)
+TEST_CASE("ClHardSwishEndToEndTestQAsymmU8")
{
- HardSwishEndToEndTest<armnn::DataType::QAsymmU8>(defaultBackends);
+ HardSwishEndToEndTest<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQSymmS16)
+TEST_CASE("ClHardSwishEndToEndTestQSymmS16")
{
- HardSwishEndToEndTest<armnn::DataType::QSymmS16>(defaultBackends);
+ HardSwishEndToEndTest<armnn::DataType::QSymmS16>(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<armnn::DataType::Float32>(defaultBackends);
+ FillEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(RefFillEndToEndTestFloat16)
+TEST_CASE("RefFillEndToEndTestFloat16")
{
- FillEndToEnd<armnn::DataType::Float16>(defaultBackends);
+ FillEndToEnd<armnn::DataType::Float16>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClFillEndToEndTestInt32)
+TEST_CASE("ClFillEndToEndTestInt32")
{
- FillEndToEnd<armnn::DataType::Signed32>(defaultBackends);
+ FillEndToEnd<armnn::DataType::Signed32>(clDefaultBackends);
}
// Prelu
-BOOST_AUTO_TEST_CASE(ClPreluEndToEndFloat32Test)
+TEST_CASE("ClPreluEndToEndFloat32Test")
{
- PreluEndToEndNegativeTest<armnn::DataType::Float32>(defaultBackends);
+ PreluEndToEndNegativeTest<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClPreluEndToEndTestUint8)
+TEST_CASE("ClPreluEndToEndTestUint8")
{
- PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(defaultBackends);
+ PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(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<armnn::DataType::Float32>(defaultBackends);
+ Splitter1dEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndUint8Test)
+TEST_CASE("ClSplitter1dEndToEndUint8Test")
{
- Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndTest)
+TEST_CASE("ClSplitter2dDim0EndToEndTest")
{
- Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ Splitter2dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndTest)
+TEST_CASE("ClSplitter2dDim1EndToEndTest")
{
- Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ Splitter2dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndUint8Test)
+TEST_CASE("ClSplitter2dDim0EndToEndUint8Test")
{
- Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndUint8Test)
+TEST_CASE("ClSplitter2dDim1EndToEndUint8Test")
{
- Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndTest)
+TEST_CASE("ClSplitter3dDim0EndToEndTest")
{
- Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ Splitter3dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndTest)
+TEST_CASE("ClSplitter3dDim1EndToEndTest")
{
- Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ Splitter3dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndTest)
+TEST_CASE("ClSplitter3dDim2EndToEndTest")
{
- Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ Splitter3dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndUint8Test)
+TEST_CASE("ClSplitter3dDim0EndToEndUint8Test")
{
- Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndUint8Test)
+TEST_CASE("ClSplitter3dDim1EndToEndUint8Test")
{
- Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndUint8Test)
+TEST_CASE("ClSplitter3dDim2EndToEndUint8Test")
{
- Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndTest)
+TEST_CASE("ClSplitter4dDim0EndToEndTest")
{
- Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ Splitter4dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndTest)
+TEST_CASE("ClSplitter4dDim1EndToEndTest")
{
- Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ Splitter4dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndTest)
+TEST_CASE("ClSplitter4dDim2EndToEndTest")
{
- Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ Splitter4dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndTest)
+TEST_CASE("ClSplitter4dDim3EndToEndTest")
{
- Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ Splitter4dDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndUint8Test)
+TEST_CASE("ClSplitter4dDim0EndToEndUint8Test")
{
- Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndUint8Test)
+TEST_CASE("ClSplitter4dDim1EndToEndUint8Test")
{
- Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndUint8Test)
+TEST_CASE("ClSplitter4dDim2EndToEndUint8Test")
{
- Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndUint8Test)
+TEST_CASE("ClSplitter4dDim3EndToEndUint8Test")
{
- Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
// TransposeConvolution2d
-BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNchwTest)
+TEST_CASE("ClTransposeConvolution2dEndToEndFloatNchwTest")
{
TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
- defaultBackends, armnn::DataLayout::NCHW);
+ clDefaultBackends, armnn::DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NchwTest)
+TEST_CASE("ClTransposeConvolution2dEndToEndUint8NchwTest")
{
TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
- defaultBackends, armnn::DataLayout::NCHW);
+ clDefaultBackends, armnn::DataLayout::NCHW);
}
-BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNhwcTest)
+TEST_CASE("ClTransposeConvolution2dEndToEndFloatNhwcTest")
{
TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
- defaultBackends, armnn::DataLayout::NHWC);
+ clDefaultBackends, armnn::DataLayout::NHWC);
}
-BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NhwcTest)
+TEST_CASE("ClTransposeConvolution2dEndToEndUint8NhwcTest")
{
TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
- 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<armnn::DataType::Float32>(defaultBackends);
+ ArgMaxEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinSimpleTest)
+TEST_CASE("ClArgMinSimpleTest")
{
- ArgMinEndToEndSimple<armnn::DataType::Float32>(defaultBackends);
+ ArgMinEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis0Test)
+TEST_CASE("ClArgMaxAxis0Test")
{
- ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinAxis0Test)
+TEST_CASE("ClArgMinAxis0Test")
{
- ArgMinAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ArgMinAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis1Test)
+TEST_CASE("ClArgMaxAxis1Test")
{
- ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinAxis1Test)
+TEST_CASE("ClArgMinAxis1Test")
{
- ArgMinAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ArgMinAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis2Test)
+TEST_CASE("ClArgMaxAxis2Test")
{
- ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinAxis2Test)
+TEST_CASE("ClArgMinAxis2Test")
{
- ArgMinAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ArgMinAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis3Test)
+TEST_CASE("ClArgMaxAxis3Test")
{
- ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinAxis3Test)
+TEST_CASE("ClArgMinAxis3Test")
{
- ArgMinAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
+ ArgMinAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMaxSimpleTestQAsymmU8)
+TEST_CASE("ClArgMaxSimpleTestQAsymmU8")
{
- ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinSimpleTestQAsymmU8)
+TEST_CASE("ClArgMinSimpleTestQAsymmU8")
{
- ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis0TestQAsymmU8)
+TEST_CASE("ClArgMaxAxis0TestQAsymmU8")
{
- ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinAxis0TestQAsymmU8)
+TEST_CASE("ClArgMinAxis0TestQAsymmU8")
{
- ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis1TestQAsymmU8)
+TEST_CASE("ClArgMaxAxis1TestQAsymmU8")
{
- ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinAxis1TestQAsymmU8)
+TEST_CASE("ClArgMinAxis1TestQAsymmU8")
{
- ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis2TestQAsymmU8)
+TEST_CASE("ClArgMaxAxis2TestQAsymmU8")
{
- ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinAxis2TestQAsymmU8)
+TEST_CASE("ClArgMinAxis2TestQAsymmU8")
{
- ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMaxAxis3TestQAsymmU8)
+TEST_CASE("ClArgMaxAxis3TestQAsymmU8")
{
- ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}
-BOOST_AUTO_TEST_CASE(ClArgMinAxis3TestQAsymmU8)
+TEST_CASE("ClArgMinAxis3TestQAsymmU8")
{
- ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
+ ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(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 183b8ca..7721206 100644
--- a/src/backends/cl/test/ClFallbackTests.cpp
+++ b/src/backends/cl/test/ClFallbackTests.cpp
@@ -7,11 +7,11 @@
#include <test/GraphUtils.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
-BOOST_AUTO_TEST_SUITE(ClFallback)
-
-BOOST_AUTO_TEST_CASE(ClImportEnabledFallbackToNeon)
+TEST_SUITE("ClFallback")
+{
+TEST_CASE("ClImportEnabledFallbackToNeon")
{
using namespace armnn;
@@ -62,18 +62,18 @@
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 @@
size_t space = totalBytes + alignment + alignment;
auto inputData0 = std::make_unique<uint8_t[]>(space);
void* alignedInputPtr0 = inputData0.get();
- BOOST_CHECK(std::align(alignment, totalBytes, alignedInputPtr0, space));
+ CHECK(std::align(alignment, totalBytes, alignedInputPtr0, space));
auto* intputPtr0 = reinterpret_cast<float*>(alignedInputPtr0);
std::copy(inputValue0.begin(), inputValue0.end(), intputPtr0);
auto inputData1 = std::make_unique<uint8_t[]>(space);
void* alignedInputPtr1 = inputData1.get();
- BOOST_CHECK(std::align(alignment, totalBytes, alignedInputPtr1, space));
+ CHECK(std::align(alignment, totalBytes, alignedInputPtr1, space));
auto* intputPtr1 = reinterpret_cast<float*>(alignedInputPtr1);
std::copy(inputValue1.begin(), inputValue1.end(), intputPtr1);
@@ -145,19 +145,19 @@
// 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 @@
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 @@
// 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 @@
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 @@
size_t space = totalBytes + alignment + alignment;
auto inputData0 = std::make_unique<uint8_t[]>(space);
void* alignedInputPtr0 = inputData0.get();
- BOOST_CHECK(std::align(alignment, totalBytes, alignedInputPtr0, space));
+ CHECK(std::align(alignment, totalBytes, alignedInputPtr0, space));
auto* intputPtr0 = reinterpret_cast<float*>(alignedInputPtr0);
std::copy(inputValue0.begin(), inputValue0.end(), intputPtr0);
auto inputData1 = std::make_unique<uint8_t[]>(space);
void* alignedInputPtr1 = inputData1.get();
- BOOST_CHECK(std::align(alignment, totalBytes, alignedInputPtr1, space));
+ CHECK(std::align(alignment, totalBytes, alignedInputPtr1, space));
auto* intputPtr1 = reinterpret_cast<float*>(alignedInputPtr1);
std::copy(inputValue1.begin(), inputValue1.end(), intputPtr1);
@@ -424,23 +424,23 @@
// 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 @@
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 @@
// 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 0c6a9c6..fee40fd 100644
--- a/src/backends/cl/test/ClImportTensorHandleFactoryTests.cpp
+++ b/src/backends/cl/test/ClImportTensorHandleFactoryTests.cpp
@@ -3,14 +3,17 @@
// SPDX-License-Identifier: MIT
//
+#include <armnn/utility/Assert.hpp>
+
#include <cl/ClImportTensorHandleFactory.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
-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<MemorySourceFlags>(MemorySource::Malloc),
@@ -18,11 +21,11 @@
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<MemorySourceFlags>(MemorySource::Malloc),
@@ -32,24 +35,24 @@
// 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<MemorySourceFlags>(MemorySource::Malloc));
- BOOST_ASSERT(tensorHandle->GetShape() == tensorShape);
+ ARMNN_ASSERT(tensorHandle);
+ ARMNN_ASSERT(tensorHandle->GetImportFlags() == static_cast<MemorySourceFlags>(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<MemorySourceFlags>(MemorySource::Malloc));
- BOOST_ASSERT(tensorHandle->GetShape() == tensorShape);
+ CHECK(tensorHandle);
+ ARMNN_ASSERT(tensorHandle->GetImportFlags() == static_cast<MemorySourceFlags>(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<MemorySourceFlags>(MemorySource::Malloc));
- BOOST_ASSERT(tensorHandle->GetShape() == tensorShape);
+ CHECK(tensorHandle);
+ ARMNN_ASSERT(tensorHandle->GetImportFlags() == static_cast<MemorySourceFlags>(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<MemorySourceFlags>(MemorySource::Malloc),
@@ -63,12 +66,12 @@
// 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<MemorySourceFlags>(MemorySource::Malloc),
@@ -84,10 +87,10 @@
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<MemorySourceFlags>(MemorySource::Malloc),
@@ -102,10 +105,10 @@
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<MemorySourceFlags>(MemorySource::Malloc),
@@ -119,7 +122,7 @@
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 3c8bd67..931729a 100644
--- a/src/backends/cl/test/ClImportTensorHandleTests.cpp
+++ b/src/backends/cl/test/ClImportTensorHandleTests.cpp
@@ -9,16 +9,17 @@
#include <cl/ClImportTensorHandleFactory.hpp>
#include <cl/test/ClContextControlFixture.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
+
#include <armnn/IRuntime.hpp>
#include <armnn/INetwork.hpp>
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<MemorySourceFlags>(MemorySource::Malloc),
static_cast<MemorySourceFlags>(MemorySource::Malloc));
@@ -44,10 +45,10 @@
size_t space = totalBytes + alignment + alignment;
auto testData = std::make_unique<uint8_t[]>(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<float*>(alignedPtr);
@@ -60,11 +61,11 @@
// 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<MemorySourceFlags>(MemorySource::Malloc),
static_cast<MemorySourceFlags>(MemorySource::Malloc));
@@ -84,13 +85,13 @@
size_t space = totalBytes + alignment + alignment;
auto testData = std::make_unique<uint8_t[]>(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<MemorySource>(256);
ClImportTensorHandleFactory handleFactory(static_cast<MemorySourceFlags>(invalidMemSource),
@@ -108,10 +109,10 @@
};
// 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 @@
optOptions.m_ImportEnabled = true;
std::vector<armnn::BackendId> 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 @@
size_t space = totalBytes + alignment + alignment;
auto inputData = std::make_unique<uint8_t[]>(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<float*>(alignedInputPtr);
@@ -166,7 +167,7 @@
auto outputData = std::make_unique<uint8_t[]>(space);
void* alignedOutputPtr = outputData.get();
- BOOST_CHECK(std::align(alignment, totalBytes, alignedOutputPtr, space));
+ CHECK(std::align(alignment, totalBytes, alignedOutputPtr, space));
auto* outputPtr = reinterpret_cast<float*>(alignedOutputPtr);
std::fill_n(outputPtr, numElements, -10.0f);
@@ -192,26 +193,26 @@
// 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<float*>(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 d188a8e..2c24a53 100644
--- a/src/backends/cl/test/ClJsonPrinterTests.cpp
+++ b/src/backends/cl/test/ClJsonPrinterTests.cpp
@@ -8,16 +8,13 @@
#include <cl/test/ClContextControlFixture.hpp>
#include <backendsCommon/test/JsonPrinterTestImpl.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
#include <vector>
-BOOST_FIXTURE_TEST_SUITE(ClJsonPrinter, ClProfilingContextControlFixture)
-
-BOOST_AUTO_TEST_CASE(SoftmaxProfilerJsonPrinterGpuAccTest)
+TEST_CASE_FIXTURE(ClProfilingContextControlFixture, "SoftmaxProfilerJsonPrinterGpuAccTest")
{
std::vector<armnn::BackendId> 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 794a45f..b18da11 100644
--- a/src/backends/cl/test/ClLayerSupportTests.cpp
+++ b/src/backends/cl/test/ClLayerSupportTests.cpp
@@ -16,176 +16,176 @@
#include <backendsCommon/test/IsLayerSupportedTestImpl.hpp>
#include <backendsCommon/test/LayerTests.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
#include <string>
-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<armnn::ClWorkloadFactory, armnn::DataType::Float16>(&factory);
}
-BOOST_FIXTURE_TEST_CASE(IsLayerSupportedFloat32Cl, ClContextControlFixture)
+TEST_CASE_FIXTURE(ClContextControlFixture, "IsLayerSupportedFloat32Cl")
{
armnn::ClWorkloadFactory factory =
ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
IsLayerSupportedTests<armnn::ClWorkloadFactory, armnn::DataType::Float32>(&factory);
}
-BOOST_FIXTURE_TEST_CASE(IsLayerSupportedQAsymmU8Cl, ClContextControlFixture)
+TEST_CASE_FIXTURE(ClContextControlFixture, "IsLayerSupportedQAsymmU8Cl")
{
armnn::ClWorkloadFactory factory =
ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
IsLayerSupportedTests<armnn::ClWorkloadFactory, armnn::DataType::QAsymmU8>(&factory);
}
-BOOST_FIXTURE_TEST_CASE(IsLayerSupportedQAsymmS8Cl, ClContextControlFixture)
+TEST_CASE_FIXTURE(ClContextControlFixture, "IsLayerSupportedQAsymmS8Cl")
{
armnn::ClWorkloadFactory factory =
ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
IsLayerSupportedTests<armnn::ClWorkloadFactory, armnn::DataType::QAsymmS8>(&factory);
}
-BOOST_FIXTURE_TEST_CASE(IsLayerSupportedQSymmS8Cl, ClContextControlFixture)
+TEST_CASE_FIXTURE(ClContextControlFixture, "IsLayerSupportedQSymmS8Cl")
{
armnn::ClWorkloadFactory factory =
ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
IsLayerSupportedTests<armnn::ClWorkloadFactory, armnn::DataType::QSymmS8>(&factory);
}
-BOOST_FIXTURE_TEST_CASE(IsConvertFp16ToFp32SupportedCl, ClContextControlFixture)
+TEST_CASE_FIXTURE(ClContextControlFixture, "IsConvertFp16ToFp32SupportedCl")
{
std::string reasonIfUnsupported;
bool result = IsConvertLayerSupportedTests<armnn::ClWorkloadFactory, armnn::ConvertFp16ToFp32Layer,
armnn::DataType::Float16, armnn::DataType::Float32>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
}
-BOOST_FIXTURE_TEST_CASE(IsConvertFp16ToFp32SupportedFp32InputCl, ClContextControlFixture)
+TEST_CASE_FIXTURE(ClContextControlFixture, "IsConvertFp16ToFp32SupportedFp32InputCl")
{
std::string reasonIfUnsupported;
bool result = IsConvertLayerSupportedTests<armnn::ClWorkloadFactory, armnn::ConvertFp16ToFp32Layer,
armnn::DataType::Float32, armnn::DataType::Float32>(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<armnn::ClWorkloadFactory, armnn::ConvertFp16ToFp32Layer,
armnn::DataType::Float16, armnn::DataType::Float16>(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<armnn::ClWorkloadFactory, armnn::ConvertFp32ToFp16Layer,
armnn::DataType::Float32, armnn::DataType::Float16>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
}
-BOOST_FIXTURE_TEST_CASE(IsConvertFp32ToFp16SupportedFp16InputCl, ClContextControlFixture)
+TEST_CASE_FIXTURE(ClContextControlFixture, "IsConvertFp32ToFp16SupportedFp16InputCl")
{
std::string reasonIfUnsupported;
bool result = IsConvertLayerSupportedTests<armnn::ClWorkloadFactory, armnn::ConvertFp32ToFp16Layer,
armnn::DataType::Float16, armnn::DataType::Float16>(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<armnn::ClWorkloadFactory, armnn::ConvertFp32ToFp16Layer,
armnn::DataType::Float32, armnn::DataType::Float32>(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<armnn::ClWorkloadFactory,
armnn::DataType::Boolean, armnn::DataType::Boolean>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
}
-BOOST_FIXTURE_TEST_CASE(IsLogicalBinaryBroadcastSupportedCl, ClContextControlFixture)
+TEST_CASE_FIXTURE(ClContextControlFixture, "IsLogicalBinaryBroadcastSupportedCl")
{
std::string reasonIfUnsupported;
bool result = IsLogicalBinaryLayerBroadcastSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::Boolean, armnn::DataType::Boolean>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
}
-BOOST_FIXTURE_TEST_CASE(IsMeanSupportedCl, ClContextControlFixture)
+TEST_CASE_FIXTURE(ClContextControlFixture, "IsMeanSupportedCl")
{
std::string reasonIfUnsupported;
bool result = IsMeanLayerSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::Float32, armnn::DataType::Float32>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
}
-BOOST_AUTO_TEST_CASE(IsConstantSupportedCl)
+TEST_CASE("IsConstantSupportedCl")
{
std::string reasonIfUnsupported;
bool result = IsConstantLayerSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::Float16>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
result = IsConstantLayerSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::Float32>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
result = IsConstantLayerSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::QAsymmU8>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
result = IsConstantLayerSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::Boolean>(reasonIfUnsupported);
- BOOST_CHECK(!result);
+ CHECK(!result);
result = IsConstantLayerSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::QSymmS16>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
result = IsConstantLayerSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::QSymmS8>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
result = IsConstantLayerSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::QAsymmS8>(reasonIfUnsupported);
- BOOST_CHECK(result);
+ CHECK(result);
result = IsConstantLayerSupportedTests<armnn::ClWorkloadFactory,
armnn::DataType::BFloat16>(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 918ef03..1c3c831 100644
--- a/src/backends/cl/test/ClLayerTests.cpp
+++ b/src/backends/cl/test/ClLayerTests.cpp
@@ -19,12 +19,13 @@
#include <arm_compute/core/CL/CLKernelLibrary.h>
#include <arm_compute/runtime/CL/CLScheduler.h>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
#include <iostream>
#include <string>
-BOOST_FIXTURE_TEST_SUITE(Compute_ArmComputeCl, ClContextControlFixture)
+TEST_SUITE("Compute_ArmComputeCl")
+{
using namespace armnn;
@@ -34,1267 +35,1870 @@
// 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<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcFloat322, BatchToSpaceNdNhwcTest2<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcFloat323, BatchToSpaceNdNhwcTest3<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcFloat321,
+ ClContextControlFixture,
+ BatchToSpaceNdNhwcTest1<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcFloat322,
+ ClContextControlFixture,
+ BatchToSpaceNdNhwcTest2<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcFloat323,
+ ClContextControlFixture,
+ BatchToSpaceNdNhwcTest3<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwFloat321, BatchToSpaceNdNchwTest1<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwFloat322, BatchToSpaceNdNchwTest2<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwFloat323, BatchToSpaceNdNchwTest3<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwFloat321,
+ ClContextControlFixture,
+ BatchToSpaceNdNchwTest1<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwFloat322,
+ ClContextControlFixture,
+ BatchToSpaceNdNchwTest2<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwFloat323,
+ ClContextControlFixture,
+ BatchToSpaceNdNchwTest3<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcInt1, BatchToSpaceNdNhwcTest1<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcInt2, BatchToSpaceNdNhwcTest2<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcInt3, BatchToSpaceNdNhwcTest3<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcInt1,
+ ClContextControlFixture,
+ BatchToSpaceNdNhwcTest1<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcInt2,
+ ClContextControlFixture,
+ BatchToSpaceNdNhwcTest2<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcInt3,
+ ClContextControlFixture,
+ BatchToSpaceNdNhwcTest3<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwInt1, BatchToSpaceNdNchwTest1<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwInt2, BatchToSpaceNdNchwTest2<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwInt3, BatchToSpaceNdNchwTest3<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwInt1,
+ ClContextControlFixture,
+ BatchToSpaceNdNchwTest1<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwInt2,
+ ClContextControlFixture,
+ BatchToSpaceNdNchwTest2<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwInt3,
+ ClContextControlFixture,
+ BatchToSpaceNdNchwTest3<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcUint1, BatchToSpaceNdNhwcTest1<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcUint2, BatchToSpaceNdNhwcTest2<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNhwcUint3, BatchToSpaceNdNhwcTest3<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcUint1,
+ ClContextControlFixture,
+ BatchToSpaceNdNhwcTest1<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcUint2,
+ ClContextControlFixture,
+ BatchToSpaceNdNhwcTest2<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNhwcUint3,
+ ClContextControlFixture,
+ BatchToSpaceNdNhwcTest3<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwUint1, BatchToSpaceNdNchwTest1<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwUint2, BatchToSpaceNdNchwTest2<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(BatchToSpaceNdNchwUint3, BatchToSpaceNdNchwTest3<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwUint1,
+ ClContextControlFixture,
+ BatchToSpaceNdNchwTest1<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwUint2,
+ ClContextControlFixture,
+ BatchToSpaceNdNchwTest2<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(BatchToSpaceNdNchwUint3,
+ ClContextControlFixture,
+ BatchToSpaceNdNchwTest3<DataType::QAsymmU8>)
// 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<DataType::QAsymmU8>, false, true)
-ARMNN_AUTO_TEST_CASE_WITH_THF(FullyConnectedBiasedUint8, FullyConnectedTest<DataType::QAsymmU8>, true, true)
+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<DataType::QAsymmU8>,
+ false,
+ true)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(FullyConnectedBiasedUint8,
+ ClContextControlFixture,
+ FullyConnectedTest<DataType::QAsymmU8>,
+ true,
+ true)
-ARMNN_AUTO_TEST_CASE_WITH_THF(FullyConnectedLarge, FullyConnectedLargeTest, false)
-ARMNN_AUTO_TEST_CASE_WITH_THF(FullyConnectedLargeTransposed, FullyConnectedLargeTest, true)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(FullyConnectedLarge,
+ ClContextControlFixture,
+ FullyConnectedLargeTest,
+ false)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(FullyConnectedLargeTransposed,
+ ClContextControlFixture,
+ FullyConnectedLargeTest,
+ true)
// Convolution
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution1d, Convolution1dTest, true)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution1d,
+ ClContextControlFixture,
+ 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_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(UnbiasedConvolution2dSquare, SimpleConvolution2d3x3Test, false, DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleConvolution2dAsymmetricPadding,
- Convolution2dAsymmetricPaddingTest,
- DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedConvolution2dSquare,
+ ClContextControlFixture,
+ SimpleConvolution2d3x3Test,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution2dAsymmetricPadding,
+ ClContextControlFixture,
+ 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_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(SimpleConvolution2dSquareNhwc, SimpleConvolution2d3x3NhwcTest, false)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleConvolution2dSquareNhwc,
+ ClContextControlFixture,
+ SimpleConvolution2d3x3NhwcTest,
+ false)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d3x3Dilation3x3,
- Convolution2d3x3Dilation3x3Test<DataType::Float32, DataType::Float32>,
- false,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d3x3Dilation3x3Nhwc,
- Convolution2d3x3Dilation3x3Test<DataType::Float32, DataType::Float32>,
- false,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d3x3Dilation3x3Uint8,
- Convolution2d3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>,
- false,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d3x3Dilation3x3NhwcUint8,
- Convolution2d3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>,
- false,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x3x3Dilation3x3,
- Convolution2d2x3x3Dilation3x3Test<DataType::Float32, DataType::Float32>,
- false,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x3x3Dilation3x3Nhwc,
- Convolution2d2x3x3Dilation3x3Test<DataType::Float32, DataType::Float32>,
- false,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x3x3Dilation3x3Uint8,
- Convolution2d2x3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>,
- false,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x3x3Dilation3x3NhwcUint8,
- Convolution2d2x3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>,
- false,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3,
- Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::Float32, DataType::Float32>,
- false,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Nhwc,
- Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::Float32, DataType::Float32>,
- false,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Uint8,
- Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::QAsymmU8, DataType::Signed32>,
- false,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3NhwcUint8,
- Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::QAsymmU8, DataType::Signed32>,
- false,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d3x3Dilation3x3,
+ ClContextControlFixture,
+ Convolution2d3x3Dilation3x3Test<DataType::Float32, DataType::Float32>,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d3x3Dilation3x3Nhwc,
+ ClContextControlFixture,
+ Convolution2d3x3Dilation3x3Test<DataType::Float32, DataType::Float32>,
+ false,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d3x3Dilation3x3Uint8,
+ ClContextControlFixture,
+ Convolution2d3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d3x3Dilation3x3NhwcUint8,
+ ClContextControlFixture,
+ Convolution2d3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>,
+ false,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x3x3Dilation3x3,
+ ClContextControlFixture,
+ Convolution2d2x3x3Dilation3x3Test<DataType::Float32, DataType::Float32>,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x3x3Dilation3x3Nhwc,
+ ClContextControlFixture,
+ Convolution2d2x3x3Dilation3x3Test<DataType::Float32, DataType::Float32>,
+ false,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x3x3Dilation3x3Uint8,
+ ClContextControlFixture,
+ Convolution2d2x3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x3x3Dilation3x3NhwcUint8,
+ ClContextControlFixture,
+ Convolution2d2x3x3Dilation3x3Test<DataType::QAsymmU8, DataType::Signed32>,
+ false,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3,
+ ClContextControlFixture,
+ Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::Float32, DataType::Float32>,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Nhwc,
+ ClContextControlFixture,
+ Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::Float32, DataType::Float32>,
+ false,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Uint8,
+ ClContextControlFixture,
+ Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::QAsymmU8, DataType::Signed32>,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Convolution2d2x2Dilation2x2Padding2x2Stride3x3NhwcUint8,
+ ClContextControlFixture,
+ Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<DataType::QAsymmU8, DataType::Signed32>,
+ 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(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_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_CASE_WITH_THF(DepthwiseConvolution2dDepthNhwc, DepthwiseConvolution2dDepthNhwcTest, false)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dDepthNhwc,
+ ClContextControlFixture,
+ 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_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_CASE_WITH_THF(DepthwiseConvolution2dDepthMul64, DepthwiseConvolution2dDepthMul64Test);
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(DepthwiseConvolution2dDepthMul64,
+ ClContextControlFixture,
+ 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(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<DataType::QAsymmU8>, 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<DataType::QAsymmU8>,
+ 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_FIXTURE_WITH_THF(SimpleMaxPooling2dSize3x3Stride2x4,
+ ClContextControlFixture,
+ SimpleMaxPooling2dSize3x3Stride2x4Test,
+ true)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleMaxPooling2dSize3x3Stride2x4Uint8,
+ ClContextControlFixture,
+ 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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(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<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1Float32, RankDimSize1Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QAsymmU8, RankDimSize1Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1Signed32, RankDimSize1Test<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QSymmS16, RankDimSize1Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize1QAsymmS8, RankDimSize1Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1Float16, ClContextControlFixture, RankDimSize1Test<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1Float32, ClContextControlFixture, RankDimSize1Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1QAsymmU8, ClContextControlFixture, RankDimSize1Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1Signed32, ClContextControlFixture, RankDimSize1Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1QSymmS16, ClContextControlFixture, RankDimSize1Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize1QAsymmS8, ClContextControlFixture, RankDimSize1Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2Float16, RankDimSize2Test<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2Float32, RankDimSize2Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QAsymmU8, RankDimSize2Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2Signed32, RankDimSize2Test<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QSymmS16, RankDimSize2Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize2QAsymmS8, RankDimSize2Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2Float16, ClContextControlFixture, RankDimSize2Test<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2Float32, ClContextControlFixture, RankDimSize2Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2QAsymmU8, ClContextControlFixture, RankDimSize2Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2Signed32, ClContextControlFixture, RankDimSize2Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2QSymmS16, ClContextControlFixture, RankDimSize2Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize2QAsymmS8, ClContextControlFixture, RankDimSize2Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3Float16, RankDimSize3Test<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3Float32, RankDimSize3Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QAsymmU8, RankDimSize3Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3Signed32, RankDimSize3Test<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QSymmS16, RankDimSize3Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize3QAsymmS8, RankDimSize3Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3Float16, ClContextControlFixture, RankDimSize3Test<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3Float32, ClContextControlFixture, RankDimSize3Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3QAsymmU8, ClContextControlFixture, RankDimSize3Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3Signed32, ClContextControlFixture, RankDimSize3Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3QSymmS16, ClContextControlFixture, RankDimSize3Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize3QAsymmS8, ClContextControlFixture, RankDimSize3Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4Float16, RankDimSize4Test<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4Float32, RankDimSize4Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QAsymmU8, RankDimSize4Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4Signed32, RankDimSize4Test<DataType::Signed32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QSymmS16, RankDimSize4Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RankDimSize4QAsymmS8, RankDimSize4Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4Float16, ClContextControlFixture, RankDimSize4Test<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4Float32, ClContextControlFixture, RankDimSize4Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4QAsymmU8, ClContextControlFixture, RankDimSize4Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4Signed32, ClContextControlFixture, RankDimSize4Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4QSymmS16, ClContextControlFixture, RankDimSize4Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RankDimSize4QAsymmS8, ClContextControlFixture, RankDimSize4Test<DataType::QAsymmS8>)
// InstanceNormalization
-ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat32Nchw, InstanceNormFloat32Test, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat16Nchw, InstanceNormFloat16Test, DataLayout::NCHW);
+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_CASE_WITH_THF(InstanceNormFloat32Nhwc, InstanceNormFloat32Test, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat16Nhwc, InstanceNormFloat16Test, DataLayout::NHWC);
+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_CASE_WITH_THF(InstanceNormFloat32Nchw2, InstanceNormFloat32Test2, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat16Nchw2, InstanceNormFloat16Test2, DataLayout::NCHW);
+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_CASE_WITH_THF(InstanceNormFloat32Nhwc2, InstanceNormFloat32Test2, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE_WITH_THF(InstanceNormFloat16Nhwc2, InstanceNormFloat16Test2, DataLayout::NHWC);
+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_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_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(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_FIXTURE_WITH_THF(Concat1d, ClContextControlFixture, Concat1dTest)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Concat1dUint8, ClContextControlFixture, 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_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_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_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_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_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_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_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_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_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_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(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<DataType::Float32>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_2, DepthToSpaceTest2<DataType::Float32>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_3, DepthToSpaceTest3<DataType::Float32>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat32_4, DepthToSpaceTest4<DataType::Float32>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat32_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::Float32>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat32_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::Float32>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat32_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::Float32>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat32_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::Float32>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_1, DepthToSpaceTest1<DataType::Float16>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_2, DepthToSpaceTest2<DataType::Float16>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_3, DepthToSpaceTest3<DataType::Float16>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwFloat16_4, DepthToSpaceTest4<DataType::Float16>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat16_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::Float16>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat16_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::Float16>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat16_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::Float16>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwFloat16_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::Float16>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt8_1, DepthToSpaceTest1<DataType::QAsymmS8>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt8_2, DepthToSpaceTest2<DataType::QAsymmS8>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt8_3, DepthToSpaceTest3<DataType::QAsymmS8>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt8_4, DepthToSpaceTest4<DataType::QAsymmS8>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt8_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::QAsymmS8>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt8_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::QAsymmS8>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt8_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::QAsymmS8>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt8_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::QAsymmS8>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_1, DepthToSpaceTest1<DataType::QAsymmU8>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_2, DepthToSpaceTest2<DataType::QAsymmU8>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_3, DepthToSpaceTest3<DataType::QAsymmU8>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwUint8_4, DepthToSpaceTest4<DataType::QAsymmU8>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwUint8_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::QAsymmU8>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwUint8_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::QAsymmU8>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwUint8_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::QAsymmU8>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwUint8_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::QAsymmU8>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_1, DepthToSpaceTest1<DataType::QSymmS16>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_2, DepthToSpaceTest2<DataType::QSymmS16>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_3, DepthToSpaceTest3<DataType::QSymmS16>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNchwInt16_4, DepthToSpaceTest4<DataType::QSymmS16>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt16_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::QSymmS16>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt16_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::QSymmS16>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt16_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::QSymmS16>, DataLayout::NCHW);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNchwInt16_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::QSymmS16>, DataLayout::NCHW);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_1, DepthToSpaceTest1<DataType::Float32>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_2, DepthToSpaceTest2<DataType::Float32>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_3, DepthToSpaceTest3<DataType::Float32>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat32_4, DepthToSpaceTest4<DataType::Float32>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat32_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::Float32>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat32_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::Float32>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat32_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::Float32>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat32_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::Float32>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_1, DepthToSpaceTest1<DataType::Float16>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_2, DepthToSpaceTest2<DataType::Float16>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_3, DepthToSpaceTest3<DataType::Float16>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcFloat16_4, DepthToSpaceTest4<DataType::Float16>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat16_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::Float16>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat16_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::Float16>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat16_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::Float16>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcFloat16_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::Float16>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt8_1, DepthToSpaceTest1<DataType::QAsymmS8>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt8_2, DepthToSpaceTest2<DataType::QAsymmS8>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt8_3, DepthToSpaceTest3<DataType::QAsymmS8>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt8_4, DepthToSpaceTest4<DataType::QAsymmS8>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt8_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::QAsymmS8>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt8_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::QAsymmS8>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt8_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::QAsymmS8>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt8_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::QAsymmS8>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_1, DepthToSpaceTest1<DataType::QAsymmU8>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_2, DepthToSpaceTest2<DataType::QAsymmU8>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_3, DepthToSpaceTest3<DataType::QAsymmU8>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcUint8_4, DepthToSpaceTest4<DataType::QAsymmU8>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcUint8_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::QAsymmU8>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcUint8_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::QAsymmU8>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcUint8_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::QAsymmU8>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcUint8_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::QAsymmU8>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_1, DepthToSpaceTest1<DataType::QSymmS16>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_2, DepthToSpaceTest2<DataType::QSymmS16>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_3, DepthToSpaceTest3<DataType::QSymmS16>, DataLayout::NHWC);
-ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_4, DepthToSpaceTest4<DataType::QSymmS16>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt16_1,
+ ClContextControlFixture, DepthToSpaceTest1<DataType::QSymmS16>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt16_2,
+ ClContextControlFixture, DepthToSpaceTest2<DataType::QSymmS16>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt16_3,
+ ClContextControlFixture, DepthToSpaceTest3<DataType::QSymmS16>, DataLayout::NHWC);
+ARMNN_AUTO_TEST_FIXTURE(DepthToSpaceNhwcInt16_4,
+ ClContextControlFixture, DepthToSpaceTest4<DataType::QSymmS16>, DataLayout::NHWC);
// Fill
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFill, SimpleFillTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFillF16, SimpleFillTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFillS32, SimpleFillTest<DataType::Signed32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFill, ClContextControlFixture, SimpleFillTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFillF16, ClContextControlFixture, SimpleFillTest<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFillS32, ClContextControlFixture, SimpleFillTest<DataType::Signed32>)
// FloorPreluUint8
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleFloor, SimpleFloorTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleFloor, ClContextControlFixture, SimpleFloorTest<DataType::Float32>)
// 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<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeInt8, SimpleReshapeTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleReshapeUint8, SimpleReshapeTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Reshape5d, Reshape5dTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ReshapeBoolean, ReshapeBooleanTest)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleReshapeFloat32, ClContextControlFixture, SimpleReshapeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleReshapeInt8, ClContextControlFixture, SimpleReshapeTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleReshapeUint8, ClContextControlFixture, SimpleReshapeTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Reshape5d, ClContextControlFixture, Reshape5dTest<DataType::Float32>)
+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_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_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_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_CASE_WITH_THF(Pad2dQSymm16, Pad2dTestCommon<DataType::QSymmS16>, 2.0f, 0, 0.0f)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Pad2dQSymm16CustomPadding, Pad2dTestCommon<DataType::QSymmS16>, 2.0f, 0, 1.0f)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Pad3dQSymm16, Pad3dTestCommon<DataType::QSymmS16>, 2.0f, 0)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Pad4dQSymm16, Pad4dTestCommon<DataType::QSymmS16>, 2.0f, 0)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Pad2dQSymm16,
+ ClContextControlFixture, Pad2dTestCommon<DataType::QSymmS16>, 2.0f, 0, 0.0f)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Pad2dQSymm16CustomPadding,
+ ClContextControlFixture, Pad2dTestCommon<DataType::QSymmS16>, 2.0f, 0, 1.0f)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Pad3dQSymm16, ClContextControlFixture, Pad3dTestCommon<DataType::QSymmS16>, 2.0f, 0)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Pad4dQSymm16, ClContextControlFixture, Pad4dTestCommon<DataType::QSymmS16>, 2.0f, 0)
// PReLU
-ARMNN_AUTO_TEST_CASE_WITH_THF(PreluFloat32, PreluTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PreluUint8, PreluTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PreluFloat32, ClContextControlFixture, PreluTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PreluUint8, ClContextControlFixture, PreluTest<DataType::QAsymmU8>)
// Permute
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimplePermuteFloat32, SimplePermuteTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteFloat32ValueSet1Test, PermuteValueSet1Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteFloat32ValueSet2Test, PermuteValueSet2Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteFloat32ValueSet3Test, PermuteValueSet3Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimplePermuteQASymmS8, SimplePermuteTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymmS8ValueSet1Test, PermuteValueSet1Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymmS8ValueSet2Test, PermuteValueSet2Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymmS8ValueSet3Test, PermuteValueSet3Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimplePermuteQASymm8, SimplePermuteTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymm8ValueSet1Test, PermuteValueSet1Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymm8ValueSet2Test, PermuteValueSet2Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PermuteQASymm8ValueSet3Test, PermuteValueSet3Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimplePermuteFloat32, ClContextControlFixture, SimplePermuteTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ PermuteFloat32ValueSet1Test, ClContextControlFixture, PermuteValueSet1Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ PermuteFloat32ValueSet2Test, ClContextControlFixture, PermuteValueSet2Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ PermuteFloat32ValueSet3Test, ClContextControlFixture, PermuteValueSet3Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ SimplePermuteQASymmS8, ClContextControlFixture, SimplePermuteTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ PermuteQASymmS8ValueSet1Test, ClContextControlFixture, PermuteValueSet1Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ PermuteQASymmS8ValueSet2Test, ClContextControlFixture, PermuteValueSet2Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ PermuteQASymmS8ValueSet3Test, ClContextControlFixture, PermuteValueSet3Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ SimplePermuteQASymm8, ClContextControlFixture, SimplePermuteTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ PermuteQASymm8ValueSet1Test, ClContextControlFixture, PermuteValueSet1Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ PermuteQASymm8ValueSet2Test, ClContextControlFixture, PermuteValueSet2Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ PermuteQASymm8ValueSet3Test, ClContextControlFixture, PermuteValueSet3Test<DataType::QAsymmU8>)
// 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<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleAxisFloat32, MeanSimpleAxisTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanKeepDimsFloat32, MeanKeepDimsTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanMultipleDimsFloat32, MeanMultipleDimsTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts1Float32, MeanVts1Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts2Float32, MeanVts2Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts3Float32, MeanVts3Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanSimpleFloat32, ClContextControlFixture, MeanSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanSimpleAxisFloat32, ClContextControlFixture, MeanSimpleAxisTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanKeepDimsFloat32, ClContextControlFixture, MeanKeepDimsTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ MeanMultipleDimsFloat32, ClContextControlFixture, MeanMultipleDimsTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts1Float32, ClContextControlFixture, MeanVts1Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts2Float32, ClContextControlFixture, MeanVts2Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts3Float32, ClContextControlFixture, MeanVts3Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleQuantisedAsymmS8, MeanSimpleTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleAxisQuantisedAsymmS8, MeanSimpleAxisTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanKeepDimsQuantisedAsymmS8, MeanKeepDimsTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanMultipleDimsQuantisedAsymmS8, MeanMultipleDimsTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts1QuantisedAsymmS8, MeanVts1Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts2QuantisedAsymmS8, MeanVts2Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts3QuantisedAsymmS8, MeanVts3Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ MeanSimpleQuantisedAsymmS8, ClContextControlFixture, MeanSimpleTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ MeanSimpleAxisQuantisedAsymmS8, ClContextControlFixture, MeanSimpleAxisTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ MeanKeepDimsQuantisedAsymmS8, ClContextControlFixture, MeanKeepDimsTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ MeanMultipleDimsQuantisedAsymmS8, ClContextControlFixture, MeanMultipleDimsTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts1QuantisedAsymmS8, ClContextControlFixture, MeanVts1Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts2QuantisedAsymmS8, ClContextControlFixture, MeanVts2Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts3QuantisedAsymmS8, ClContextControlFixture, MeanVts3Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleQuantisedAsymm8, MeanSimpleTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanSimpleAxisQuantisedAsymm8, MeanSimpleAxisTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanKeepDimsQuantisedAsymm8, MeanKeepDimsTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanMultipleDimsQuantisedAsymm8, MeanMultipleDimsTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts1QuantisedAsymm8, MeanVts1Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts2QuantisedAsymm8, MeanVts2Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MeanVts3QuantisedAsymm8, MeanVts3Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ MeanSimpleQuantisedAsymm8, ClContextControlFixture, MeanSimpleTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ MeanSimpleAxisQuantisedAsymm8, ClContextControlFixture, MeanSimpleAxisTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ MeanKeepDimsQuantisedAsymm8, ClContextControlFixture, MeanKeepDimsTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ MeanMultipleDimsQuantisedAsymm8, ClContextControlFixture, MeanMultipleDimsTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts1QuantisedAsymm8, ClContextControlFixture, MeanVts1Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts2QuantisedAsymm8, ClContextControlFixture, MeanVts2Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MeanVts3QuantisedAsymm8, ClContextControlFixture, MeanVts3Test<DataType::QAsymmU8>)
// 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_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_CASE_WITH_THF(GreaterSimpleFloat16, GreaterSimpleFloat16Test)
-ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterBroadcast1ElementFloat16, GreaterBroadcast1ElementFloat16Test)
-ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterBroadcast1dVectorFloat16, GreaterBroadcast1dVectorFloat16Test)
+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_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(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_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_CASE_WITH_THF(GreaterOrEqualSimpleFloat16, GreaterOrEqualSimpleFloat16Test)
-ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualBroadcast1ElementFloat16, GreaterOrEqualBroadcast1ElementFloat16Test)
-ARMNN_AUTO_TEST_CASE_WITH_THF(GreaterOrEqualBroadcast1dVectorFloat16, GreaterOrEqualBroadcast1dVectorFloat16Test)
+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_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(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_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_CASE_WITH_THF(LessOrEqualSimpleFloat16, LessOrEqualSimpleFloat16Test)
-ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualBroadcast1ElementFloat16, LessOrEqualBroadcast1ElementFloat16Test)
-ARMNN_AUTO_TEST_CASE_WITH_THF(LessOrEqualBroadcast1dVectorFloat16, LessOrEqualBroadcast1dVectorFloat16Test)
+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_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(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_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_CASE_WITH_THF(NotEqualSimpleFloat16, NotEqualSimpleFloat16Test)
-ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1ElementFloat16, NotEqualBroadcast1ElementFloat16Test)
-ARMNN_AUTO_TEST_CASE_WITH_THF(NotEqualBroadcast1dVectorFloat16, NotEqualBroadcast1dVectorFloat16Test)
+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_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(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<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(LogSoftmaxFloat32_1, ClContextControlFixture, LogSoftmaxTest1<DataType::Float32>)
// 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_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_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_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_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_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_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(
+ 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_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_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(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<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearInt8,
- SimpleResizeBilinearTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8,
- SimpleResizeBilinearTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNop,
- ResizeBilinearNopTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopInt8,
- ResizeBilinearNopTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8,
- ResizeBilinearNopTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMin,
- ResizeBilinearSqMinTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinInt8,
- ResizeBilinearSqMinTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8,
- ResizeBilinearSqMinTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMin,
- ResizeBilinearMinTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinInt8,
- ResizeBilinearMinTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8,
- ResizeBilinearMinTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinear,
+ ClContextControlFixture,
+ SimpleResizeBilinearTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearInt8,
+ ClContextControlFixture,
+ SimpleResizeBilinearTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearUint8,
+ ClContextControlFixture,
+ SimpleResizeBilinearTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNop,
+ ClContextControlFixture,
+ ResizeBilinearNopTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopInt8,
+ ClContextControlFixture,
+ ResizeBilinearNopTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopUint8,
+ ClContextControlFixture,
+ ResizeBilinearNopTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMin,
+ ClContextControlFixture,
+ ResizeBilinearSqMinTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinInt8,
+ ClContextControlFixture,
+ ResizeBilinearSqMinTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinUint8,
+ ClContextControlFixture,
+ ResizeBilinearSqMinTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMin,
+ ClContextControlFixture,
+ ResizeBilinearMinTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinInt8,
+ ClContextControlFixture,
+ ResizeBilinearMinTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinUint8,
+ ClContextControlFixture,
+ ResizeBilinearMinTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinear,
- HalfPixelCentersResizeBilinearTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinear,
- AlignCornersResizeBilinearTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8,
- HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8,
- AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8,
- HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8,
- AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinear,
+ ClContextControlFixture,
+ HalfPixelCentersResizeBilinearTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinear,
+ ClContextControlFixture,
+ AlignCornersResizeBilinearTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearInt8,
+ ClContextControlFixture,
+ HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearInt8,
+ ClContextControlFixture,
+ AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearUint8,
+ ClContextControlFixture,
+ HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearUint8,
+ ClContextControlFixture,
+ AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
// Resize Bilinear - NHWC
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopNhwc,
- ResizeBilinearNopTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopInt8Nhwc,
- ResizeBilinearNopTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearNopUint8Nhwc,
- ResizeBilinearNopTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearNhwc,
- SimpleResizeBilinearTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearInt8Nhwc,
- SimpleResizeBilinearTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeBilinearUint8Nhwc,
- SimpleResizeBilinearTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinNhwc,
- ResizeBilinearSqMinTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinInt8Nhwc,
- ResizeBilinearSqMinTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearSqMinUint8Nhwc,
- ResizeBilinearSqMinTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinNhwc,
- ResizeBilinearMinTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinInt8Nhwc,
- ResizeBilinearMinTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeBilinearMinUint8Nhwc,
- ResizeBilinearMinTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopNhwc,
+ ClContextControlFixture,
+ ResizeBilinearNopTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopInt8Nhwc,
+ ClContextControlFixture,
+ ResizeBilinearNopTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearNopUint8Nhwc,
+ ClContextControlFixture,
+ ResizeBilinearNopTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearNhwc,
+ ClContextControlFixture,
+ SimpleResizeBilinearTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearInt8Nhwc,
+ ClContextControlFixture,
+ SimpleResizeBilinearTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeBilinearUint8Nhwc,
+ ClContextControlFixture,
+ SimpleResizeBilinearTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinNhwc,
+ ClContextControlFixture,
+ ResizeBilinearSqMinTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinInt8Nhwc,
+ ClContextControlFixture,
+ ResizeBilinearSqMinTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearSqMinUint8Nhwc,
+ ClContextControlFixture,
+ ResizeBilinearSqMinTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinNhwc,
+ ClContextControlFixture,
+ ResizeBilinearMinTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinInt8Nhwc,
+ ClContextControlFixture,
+ ResizeBilinearMinTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeBilinearMinUint8Nhwc,
+ ClContextControlFixture,
+ ResizeBilinearMinTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearNhwc,
- HalfPixelCentersResizeBilinearTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearNhwc,
- AlignCornersResizeBilinearTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearInt8Nhwc,
- HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearInt8Nhwc,
- AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeBilinearUint8Nhwc,
- HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeBilinearUint8Nhwc,
- AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearNhwc,
+ ClContextControlFixture,
+ HalfPixelCentersResizeBilinearTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearNhwc,
+ ClContextControlFixture,
+ AlignCornersResizeBilinearTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearInt8Nhwc,
+ ClContextControlFixture,
+ HalfPixelCentersResizeBilinearTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearInt8Nhwc,
+ ClContextControlFixture,
+ AlignCornersResizeBilinearTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeBilinearUint8Nhwc,
+ ClContextControlFixture,
+ HalfPixelCentersResizeBilinearTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeBilinearUint8Nhwc,
+ ClContextControlFixture,
+ AlignCornersResizeBilinearTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
// Resize NearestNeighbor - NCHW
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighbor,
- SimpleResizeNearestNeighborTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborInt8,
- SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8,
- SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNop,
- ResizeNearestNeighborNopTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopInt8,
- ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8,
- ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMin,
- ResizeNearestNeighborSqMinTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinInt8,
- ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8,
- ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMin,
- ResizeNearestNeighborMinTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinInt8,
- ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8,
- ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMag,
- ResizeNearestNeighborMagTest<DataType::Float32>,
- DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagInt8,
- ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
- DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8,
- ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
- DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighbor,
+ ClContextControlFixture,
+ SimpleResizeNearestNeighborTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborInt8,
+ ClContextControlFixture,
+ SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborUint8,
+ ClContextControlFixture,
+ SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNop,
+ ClContextControlFixture,
+ ResizeNearestNeighborNopTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopInt8,
+ ClContextControlFixture,
+ ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopUint8,
+ ClContextControlFixture,
+ ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMin,
+ ClContextControlFixture,
+ ResizeNearestNeighborSqMinTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinInt8,
+ ClContextControlFixture,
+ ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinUint8,
+ ClContextControlFixture,
+ ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMin,
+ ClContextControlFixture,
+ ResizeNearestNeighborMinTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinInt8,
+ ClContextControlFixture,
+ ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinUint8,
+ ClContextControlFixture,
+ ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMag,
+ ClContextControlFixture,
+ ResizeNearestNeighborMagTest<DataType::Float32>,
+ DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagInt8,
+ ClContextControlFixture,
+ ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
+ DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagUint8,
+ ClContextControlFixture,
+ ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
+ DataLayout::NCHW, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbour,
- HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbour,
- AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8,
- HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8,
- AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8,
- HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8,
- AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
- DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbour,
+ ClContextControlFixture,
+ HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbour,
+ ClContextControlFixture,
+ AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8,
+ ClContextControlFixture,
+ HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourInt8,
+ ClContextControlFixture,
+ AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8,
+ ClContextControlFixture,
+ HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourUint8,
+ ClContextControlFixture,
+ AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+ DataLayout::NCHW)
// Resize NearestNeighbor - NHWC
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopNhwc,
- ResizeNearestNeighborNopTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopInt8Nhwc,
- ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborNopUint8Nhwc,
- ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborNhwc,
- SimpleResizeNearestNeighborTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborInt8Nhwc,
- SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleResizeNearestNeighborUint8Nhwc,
- SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinNhwc,
- ResizeNearestNeighborSqMinTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinInt8Nhwc,
- ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborSqMinUint8Nhwc,
- ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinNhwc,
- ResizeNearestNeighborMinTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinInt8Nhwc,
- ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMinUint8Nhwc,
- ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagNhwc,
- ResizeNearestNeighborMagTest<DataType::Float32>,
- DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagInt8Nhwc,
- ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
- DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ResizeNearestNeighborMagUint8Nhwc,
- ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
- DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopNhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborNopTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopInt8Nhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborNopTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborNopUint8Nhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborNopTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborNhwc,
+ ClContextControlFixture,
+ SimpleResizeNearestNeighborTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborInt8Nhwc,
+ ClContextControlFixture,
+ SimpleResizeNearestNeighborTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleResizeNearestNeighborUint8Nhwc,
+ ClContextControlFixture,
+ SimpleResizeNearestNeighborTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinNhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborSqMinTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinInt8Nhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborSqMinTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborSqMinUint8Nhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborSqMinTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinNhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborMinTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinInt8Nhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborMinTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMinUint8Nhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborMinTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagNhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborMagTest<DataType::Float32>,
+ DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagInt8Nhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborMagTest<DataType::QAsymmS8>,
+ DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ResizeNearestNeighborMagUint8Nhwc,
+ ClContextControlFixture,
+ ResizeNearestNeighborMagTest<DataType::QAsymmU8>,
+ DataLayout::NHWC, 0.1f, 50, 0.1f, 50)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourNhwc,
- HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourNhwc,
- AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8Nhwc,
- HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourInt8Nhwc,
- AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8Nhwc,
- HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AlignCornersResizeNearestNeighbourUint8Nhwc,
- AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourNhwc,
+ ClContextControlFixture,
+ HalfPixelCentersResizeNearestNeighbourTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourNhwc,
+ ClContextControlFixture,
+ AlignCornersResizeNearestNeighbourTest<DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourInt8Nhwc,
+ ClContextControlFixture,
+ HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourInt8Nhwc,
+ ClContextControlFixture,
+ AlignCornersResizeNearestNeighbourTest<DataType::QAsymmS8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(HalfPixelCentersResizeNearestNeighbourUint8Nhwc,
+ ClContextControlFixture,
+ HalfPixelCentersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AlignCornersResizeNearestNeighbourUint8Nhwc,
+ ClContextControlFixture,
+ AlignCornersResizeNearestNeighbourTest<DataType::QAsymmU8>,
+ DataLayout::NHWC)
// Rsqrt
-ARMNN_AUTO_TEST_CASE_WITH_THF(Rsqrt2d, Rsqrt2dTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Rsqrt3d, Rsqrt3dTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RsqrtZero, RsqrtZeroTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(RsqrtNegative, RsqrtNegativeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Rsqrt2d, ClContextControlFixture, Rsqrt2dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Rsqrt3d, ClContextControlFixture, Rsqrt3dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RsqrtZero, ClContextControlFixture, RsqrtZeroTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(RsqrtNegative, ClContextControlFixture, RsqrtNegativeTest<DataType::Float32>)
// 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<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet1Test, TransposeValueSet1Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet2Test, TransposeValueSet2Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeFloat32ValueSet3Test, TransposeValueSet3Test<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymmS8, SimpleTransposeTest<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet1Test, TransposeValueSet1Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet2Test, TransposeValueSet2Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymmS8ValueSet3Test, TransposeValueSet3Test<DataType::QAsymmS8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQASymm8, SimpleTransposeTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet1Test, TransposeValueSet1Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet2Test, TransposeValueSet2Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQASymm8ValueSet3Test, TransposeValueSet3Test<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeQSymm16, SimpleTransposeTest<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet1Test, TransposeValueSet1Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet2Test, TransposeValueSet2Test<DataType::QSymmS16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(TransposeQSymm16ValueSet3Test, TransposeValueSet3Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ SimpleTransposeFloat32, ClContextControlFixture, SimpleTransposeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeFloat32ValueSet1Test, ClContextControlFixture, TransposeValueSet1Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeFloat32ValueSet2Test, ClContextControlFixture, TransposeValueSet2Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeFloat32ValueSet3Test, ClContextControlFixture, TransposeValueSet3Test<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ SimpleTransposeQASymmS8, ClContextControlFixture, SimpleTransposeTest<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeQASymmS8ValueSet1Test, ClContextControlFixture, TransposeValueSet1Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeQASymmS8ValueSet2Test, ClContextControlFixture, TransposeValueSet2Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeQASymmS8ValueSet3Test, ClContextControlFixture, TransposeValueSet3Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ SimpleTransposeQASymm8, ClContextControlFixture, SimpleTransposeTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeQASymm8ValueSet1Test, ClContextControlFixture, TransposeValueSet1Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeQASymm8ValueSet2Test, ClContextControlFixture, TransposeValueSet2Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeQASymm8ValueSet3Test, ClContextControlFixture, TransposeValueSet3Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ SimpleTransposeQSymm16, ClContextControlFixture, SimpleTransposeTest<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeQSymm16ValueSet1Test, ClContextControlFixture, TransposeValueSet1Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeQSymm16ValueSet2Test, ClContextControlFixture, TransposeValueSet2Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ TransposeQSymm16ValueSet3Test, ClContextControlFixture, TransposeValueSet3Test<DataType::QSymmS16>)
// TransposeConvolution2d
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNchw,
- SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- true,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dFloatNhwc,
- SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- true,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nchw,
- SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(SimpleTransposeConvolution2dUint8Nhwc,
- SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleTransposeConvolution2dFloatNchw,
+ ClContextControlFixture,
+ SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ true,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleTransposeConvolution2dFloatNhwc,
+ ClContextControlFixture,
+ SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ true,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleTransposeConvolution2dUint8Nchw,
+ ClContextControlFixture,
+ SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(SimpleTransposeConvolution2dUint8Nhwc,
+ ClContextControlFixture,
+ SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNchw,
- SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- false,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNhwc,
- SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- true,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nchw,
- SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nhwc,
- SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNchw,
+ ClContextControlFixture,
+ SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedSimpleTransposeConvolution2dFloatNhwc,
+ ClContextControlFixture,
+ SimpleTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ true,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nchw,
+ ClContextControlFixture,
+ SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedSimpleTransposeConvolution2dUint8Nhwc,
+ ClContextControlFixture,
+ SimpleTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNchw,
- PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- true,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dFloatNhwc,
- PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- true,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nchw,
- PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(PaddedTransposeConvolution2dUint8Nhwc,
- PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PaddedTransposeConvolution2dFloatNchw,
+ ClContextControlFixture,
+ PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ true,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PaddedTransposeConvolution2dFloatNhwc,
+ ClContextControlFixture,
+ PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ true,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PaddedTransposeConvolution2dUint8Nchw,
+ ClContextControlFixture,
+ PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(PaddedTransposeConvolution2dUint8Nhwc,
+ ClContextControlFixture,
+ PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNchw,
- PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- false,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNhwc,
- PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- true,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nchw,
- PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nhwc,
- PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNchw,
+ ClContextControlFixture,
+ PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedPaddedTransposeConvolution2dFloatNhwc,
+ ClContextControlFixture,
+ PaddedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ true,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nchw,
+ ClContextControlFixture,
+ PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedPaddedTransposeConvolution2dUint8Nhwc,
+ ClContextControlFixture,
+ PaddedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNchw,
- StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- true,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dFloatNhwc,
- StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- true,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nchw,
- StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(StridedTransposeConvolution2dUint8Nhwc,
- StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedTransposeConvolution2dFloatNchw,
+ ClContextControlFixture,
+ StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ true,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedTransposeConvolution2dFloatNhwc,
+ ClContextControlFixture,
+ StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ true,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedTransposeConvolution2dUint8Nchw,
+ ClContextControlFixture,
+ StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(StridedTransposeConvolution2dUint8Nhwc,
+ ClContextControlFixture,
+ StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNchw,
- StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- false,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNhwc,
- StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- true,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nchw,
- StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nhwc,
- StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- true,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNchw,
+ ClContextControlFixture,
+ StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ false,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedStridedTransposeConvolution2dFloatNhwc,
+ ClContextControlFixture,
+ StridedTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ true,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nchw,
+ ClContextControlFixture,
+ StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(UnbiasedStridedTransposeConvolution2dUint8Nhwc,
+ ClContextControlFixture,
+ StridedTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ true,
+ DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNchw,
- MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dFloatNhwc,
- MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
- DataLayout::NHWC)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nchw,
- MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- DataLayout::NCHW)
-ARMNN_AUTO_TEST_CASE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nhwc,
- MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
- DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiChannelTransposeConvolution2dFloatNchw,
+ ClContextControlFixture,
+ MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiChannelTransposeConvolution2dFloatNhwc,
+ ClContextControlFixture,
+ MultiChannelTransposeConvolution2dTest<DataType::Float32, DataType::Float32>,
+ DataLayout::NHWC)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nchw,
+ ClContextControlFixture,
+ MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ DataLayout::NCHW)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(MultiChannelTransposeConvolution2dUint8Nhwc,
+ ClContextControlFixture,
+ MultiChannelTransposeConvolution2dTest<DataType::QAsymmU8, DataType::Signed32>,
+ DataLayout::NHWC)
// Abs
-ARMNN_AUTO_TEST_CASE_WITH_THF(Abs2d, Abs2dTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Abs3d, Abs3dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Abs2d, ClContextControlFixture, Abs2dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Abs3d, ClContextControlFixture, Abs3dTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AbsZero, AbsZeroTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AbsZero, ClContextControlFixture, AbsZeroTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Abs2dFloat16, Abs2dTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Abs3dFloat16, Abs3dTest<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Abs2dFloat16, ClContextControlFixture, Abs2dTest<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Abs3dFloat16, ClContextControlFixture, Abs3dTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(AbsZeroFloat16, AbsZeroTest<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(AbsZeroFloat16, ClContextControlFixture, AbsZeroTest<DataType::Float16>)
// ArgMinMax
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinFloat32, ArgMinSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxFloat32, ArgMaxSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannel, ArgMinChannelTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannel, ArgMaxChannelTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeight, ArgMaxHeightTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidth, ArgMinWidthTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinFloat32, ClContextControlFixture, ArgMinSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxFloat32, ClContextControlFixture, ArgMaxSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinChannel, ClContextControlFixture, ArgMinChannelTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxChannel, ClContextControlFixture, ArgMaxChannelTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxHeight, ClContextControlFixture, ArgMaxHeightTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinWidth, ClContextControlFixture, ArgMinWidthTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinQAsymm8, ArgMinSimpleTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxQAsymm8, ArgMaxSimpleTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinChannelQAsymm8, ArgMinChannelTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxChannelQAsymm8, ArgMaxChannelTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMaxHeightQAsymm8, ArgMaxHeightTest<DataType::QAsymmU8>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ArgMinWidthQAsymm8, ArgMinWidthTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinQAsymm8, ClContextControlFixture, ArgMinSimpleTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxQAsymm8, ClContextControlFixture, ArgMaxSimpleTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinChannelQAsymm8, ClContextControlFixture, ArgMinChannelTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxChannelQAsymm8, ClContextControlFixture, ArgMaxChannelTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMaxHeightQAsymm8, ClContextControlFixture, ArgMaxHeightTest<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ArgMinWidthQAsymm8, ClContextControlFixture, ArgMinWidthTest<DataType::QAsymmU8>)
// Neg
-ARMNN_AUTO_TEST_CASE_WITH_THF(Neg2d, Neg2dTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Neg3d, Neg3dTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(NegZero, NegZeroTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(NegNegative, NegNegativeTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Neg2dFloat16, Neg2dTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Neg3dFloat16, Neg3dTest<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Neg2d, ClContextControlFixture, Neg2dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Neg3d, ClContextControlFixture, Neg3dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(NegZero, ClContextControlFixture, NegZeroTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(NegNegative, ClContextControlFixture, NegNegativeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Neg2dFloat16, ClContextControlFixture, Neg2dTest<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Neg3dFloat16, ClContextControlFixture, Neg3dTest<DataType::Float16>)
// Exp
-ARMNN_AUTO_TEST_CASE_WITH_THF(Exp2d, Exp2dTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Exo3d, Exp3dTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ExpZero, ExpZeroTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ExpNegative, ExpNegativeTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Exp2dFloat16, Exp2dTest<DataType::Float16>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(Exp3dFloat16, Exp3dTest<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Exp2d, ClContextControlFixture, Exp2dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Exo3d, ClContextControlFixture, Exp3dTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ExpZero, ClContextControlFixture, ExpZeroTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ExpNegative, ClContextControlFixture, ExpNegativeTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Exp2dFloat16, ClContextControlFixture, Exp2dTest<DataType::Float16>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(Exp3dFloat16, ClContextControlFixture, Exp3dTest<DataType::Float16>)
// 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<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceSumSingleAxisFloat32_1, ReduceSumSingleAxisTest1<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceSumSingleAxisFloat32_2, ReduceSumSingleAxisTest2<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceSumSingleAxisFloat32_3, ReduceSumSingleAxisTest3<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReduceSumFloat32, ClContextControlFixture, ReduceSumSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ ReduceSumSingleAxisFloat32_1, ClContextControlFixture, ReduceSumSingleAxisTest1<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ ReduceSumSingleAxisFloat32_2, ClContextControlFixture, ReduceSumSingleAxisTest2<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ ReduceSumSingleAxisFloat32_3, ClContextControlFixture, ReduceSumSingleAxisTest3<DataType::Float32>)
// ReduceMax
-ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMaxFloat32, ReduceMaxSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMaxNegativeAxisFloat32, ReduceMaxNegativeAxisTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMax2Float32, ReduceMaxSimpleTest2<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReduceMaxFloat32, ClContextControlFixture, ReduceMaxSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ ReduceMaxNegativeAxisFloat32, ClContextControlFixture, ReduceMaxNegativeAxisTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReduceMax2Float32, ClContextControlFixture, ReduceMaxSimpleTest2<DataType::Float32>)
// ReduceMin
-ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMinFloat32, ReduceMinSimpleTest<DataType::Float32>)
-ARMNN_AUTO_TEST_CASE_WITH_THF(ReduceMinNegativeAxisFloat32, ReduceMinNegativeAxisTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(ReduceMinFloat32, ClContextControlFixture, ReduceMinSimpleTest<DataType::Float32>)
+ARMNN_AUTO_TEST_FIXTURE_WITH_THF(
+ ReduceMinNegativeAxisFloat32, ClContextControlFixture, ReduceMinNegativeAxisTest<DataType::Float32>)
// 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 @@
#endif
-BOOST_AUTO_TEST_SUITE_END()
+}
diff --git a/src/backends/cl/test/ClMemCopyTests.cpp b/src/backends/cl/test/ClMemCopyTests.cpp
index 1048e73..98b873f 100644
--- a/src/backends/cl/test/ClMemCopyTests.cpp
+++ b/src/backends/cl/test/ClMemCopyTests.cpp
@@ -11,44 +11,44 @@
#include <reference/RefWorkloadFactory.hpp>
#include <reference/test/RefWorkloadFactoryHelper.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
-BOOST_AUTO_TEST_SUITE(ClMemCopy)
-
-BOOST_AUTO_TEST_CASE(CopyBetweenCpuAndGpu)
+TEST_SUITE("ClMemCopy")
+{
+TEST_CASE("CopyBetweenCpuAndGpu")
{
LayerTestResult<float, 4> result =
MemCopyTest<armnn::RefWorkloadFactory, armnn::ClWorkloadFactory, armnn::DataType::Float32>(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<float, 4> result =
MemCopyTest<armnn::ClWorkloadFactory, armnn::RefWorkloadFactory, armnn::DataType::Float32>(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<float, 4> result =
MemCopyTest<armnn::RefWorkloadFactory, armnn::ClWorkloadFactory, armnn::DataType::Float32>(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<float, 4> result =
MemCopyTest<armnn::ClWorkloadFactory, armnn::RefWorkloadFactory, armnn::DataType::Float32>(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 a41c5f8..d91e9b4 100644
--- a/src/backends/cl/test/ClOptimizedNetworkTests.cpp
+++ b/src/backends/cl/test/ClOptimizedNetworkTests.cpp
@@ -14,12 +14,11 @@
#include <Filesystem.hpp>
+#include <doctest/doctest.h>
-#include <boost/test/unit_test.hpp>
-
-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 @@
std::vector<armnn::BackendId> 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 33e86b6..db01fa7 100644
--- a/src/backends/cl/test/ClRuntimeTests.cpp
+++ b/src/backends/cl/test/ClRuntimeTests.cpp
@@ -11,15 +11,15 @@
#include <test/ProfilingTestUtils.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
#ifdef WITH_VALGRIND
#include <valgrind/memcheck.h>
#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 @@
std::vector<armnn::BackendId> 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 @@
{
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 @@
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<long>(reachableAfter) - static_cast<long>(reachableBefore) < 81920);
+ CHECK(static_cast<long>(reachableAfter) - static_cast<long>(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 @@
}
#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 5afafcb..1974d4d 100644
--- a/src/backends/cl/test/Fp16SupportTest.cpp
+++ b/src/backends/cl/test/Fp16SupportTest.cpp
@@ -13,15 +13,15 @@
#include <backendsCommon/TensorHandle.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
#include <set>
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 @@
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 @@
runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
// Checks the results.
- BOOST_TEST(outputData == std::vector<Half>({ 101.0_h, 202.0_h, 303.0_h, 404.0_h})); // Add
+ CHECK(outputData == std::vector<Half>({ 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 7c8e277..0da1db7 100644
--- a/src/backends/cl/test/OpenClTimerTest.cpp
+++ b/src/backends/cl/test/OpenClTimerTest.cpp
@@ -21,7 +21,7 @@
#include <arm_compute/runtime/CL/CLScheduler.h>
-#include <boost/test/unit_test.hpp>
+#include <doctest/doctest.h>
#include <iostream>
@@ -38,11 +38,10 @@
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 @@
OpenClTimer openClTimer;
- BOOST_CHECK_EQUAL(openClTimer.GetName(), "OpenClKernelTimer");
+ CHECK_EQ(openClTimer.GetName(), "OpenClKernelTimer");
//Start the timer
openClTimer.Start();
@@ -120,15 +119,13 @@
//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