IVGCVSW-3999 Add unit tests for new comparison operations
* Refactored existing tests for Equal and Greater and moved them
to ComparisonTestImpl.cpp
* Removed EqualTestImpl.cpp and GreaterTestImpl.cpp
* Added new unit tests for GreaterOrEqual, Less, LessOrEqual
and NotEqual
Signed-off-by: Aron Virginas-Tar <Aron.Virginas-Tar@arm.com>
Change-Id: I25013200beb1acb88e83b813c5382cb277c74cd7
diff --git a/src/backends/backendsCommon/common.mk b/src/backends/backendsCommon/common.mk
index 8b45b37..5024f1e 100644
--- a/src/backends/backendsCommon/common.mk
+++ b/src/backends/backendsCommon/common.mk
@@ -42,6 +42,7 @@
test/layerTests/AdditionTestImpl.cpp \
test/layerTests/ArgMinMaxTestImpl.cpp \
test/layerTests/BatchNormalizationTestImpl.cpp \
+ test/layerTests/ComparisonTestImpl.cpp \
test/layerTests/ConcatTestImpl.cpp \
test/layerTests/ConstantTestImpl.cpp \
test/layerTests/Conv2dTestImpl.cpp \
@@ -51,12 +52,10 @@
test/layerTests/DepthToSpaceTestImpl.cpp \
test/layerTests/DequantizeTestImpl.cpp \
test/layerTests/DivisionTestImpl.cpp \
- test/layerTests/EqualTestImpl.cpp \
test/layerTests/FakeQuantizationTestImpl.cpp \
test/layerTests/FloorTestImpl.cpp \
test/layerTests/FullyConnectedTestImpl.cpp \
test/layerTests/GatherTestImpl.cpp \
- test/layerTests/GreaterTestImpl.cpp \
test/layerTests/InstanceNormalizationTestImpl.cpp \
test/layerTests/L2NormalizationTestImpl.cpp \
test/layerTests/LogSoftmaxTestImpl.cpp \
diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt
index 7449e69..8a96318 100644
--- a/src/backends/backendsCommon/test/CMakeLists.txt
+++ b/src/backends/backendsCommon/test/CMakeLists.txt
@@ -59,6 +59,7 @@
layerTests/BatchNormalizationTestImpl.cpp
layerTests/BatchNormalizationTestImpl.hpp
layerTests/BatchToSpaceNdTestImpl.hpp
+ layerTests/ComparisonTestImpl.cpp
layerTests/ComparisonTestImpl.hpp
layerTests/ConcatTestImpl.cpp
layerTests/ConcatTestImpl.hpp
@@ -80,8 +81,6 @@
layerTests/DivisionTestImpl.cpp
layerTests/DivisionTestImpl.hpp
layerTests/ElementwiseTestImpl.hpp
- layerTests/EqualTestImpl.cpp
- layerTests/EqualTestImpl.hpp
layerTests/FakeQuantizationTestImpl.cpp
layerTests/FakeQuantizationTestImpl.hpp
layerTests/FloorTestImpl.cpp
@@ -90,8 +89,6 @@
layerTests/FullyConnectedTestImpl.hpp
layerTests/GatherTestImpl.cpp
layerTests/GatherTestImpl.hpp
- layerTests/GreaterTestImpl.cpp
- layerTests/GreaterTestImpl.hpp
layerTests/InstanceNormalizationTestImpl.cpp
layerTests/InstanceNormalizationTestImpl.hpp
layerTests/L2NormalizationTestImpl.cpp
diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp
index eb41314..05c307e 100644
--- a/src/backends/backendsCommon/test/LayerTests.hpp
+++ b/src/backends/backendsCommon/test/LayerTests.hpp
@@ -11,6 +11,7 @@
#include <backendsCommon/test/layerTests/ArgMinMaxTestImpl.hpp>
#include <backendsCommon/test/layerTests/BatchNormalizationTestImpl.hpp>
#include <backendsCommon/test/layerTests/BatchToSpaceNdTestImpl.hpp>
+#include <backendsCommon/test/layerTests/ComparisonTestImpl.hpp>
#include <backendsCommon/test/layerTests/ConcatTestImpl.hpp>
#include <backendsCommon/test/layerTests/ConvertFp16ToFp32TestImpl.hpp>
#include <backendsCommon/test/layerTests/ConvertFp32ToFp16TestImpl.hpp>
@@ -21,12 +22,10 @@
#include <backendsCommon/test/layerTests/DequantizeTestImpl.hpp>
#include <backendsCommon/test/layerTests/DetectionPostProcessTestImpl.hpp>
#include <backendsCommon/test/layerTests/DivisionTestImpl.hpp>
-#include <backendsCommon/test/layerTests/EqualTestImpl.hpp>
#include <backendsCommon/test/layerTests/FakeQuantizationTestImpl.hpp>
#include <backendsCommon/test/layerTests/FloorTestImpl.hpp>
#include <backendsCommon/test/layerTests/FullyConnectedTestImpl.hpp>
#include <backendsCommon/test/layerTests/GatherTestImpl.hpp>
-#include <backendsCommon/test/layerTests/GreaterTestImpl.hpp>
#include <backendsCommon/test/layerTests/InstanceNormalizationTestImpl.hpp>
#include <backendsCommon/test/layerTests/L2NormalizationTestImpl.hpp>
#include <backendsCommon/test/layerTests/LogSoftmaxTestImpl.hpp>
diff --git a/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.cpp
new file mode 100644
index 0000000..9da1d42
--- /dev/null
+++ b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.cpp
@@ -0,0 +1,935 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ComparisonTestImpl.hpp"
+
+#include <armnn/ArmNN.hpp>
+
+#include <Half.hpp>
+#include <ResolveType.hpp>
+
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+
+#include <backendsCommon/test/QuantizeHelper.hpp>
+#include <backendsCommon/test/TensorCopyUtils.hpp>
+#include <backendsCommon/test/WorkloadTestUtils.hpp>
+
+#include <test/TensorHelpers.hpp>
+
+#include <boost/assert.hpp>
+
+namespace
+{
+
+template <std::size_t NumDims,
+ armnn::DataType ArmnnInType,
+ typename InType = armnn::ResolveType<ArmnnInType>>
+LayerTestResult<uint8_t, NumDims> ComparisonTestImpl(
+ armnn::IWorkloadFactory & workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
+ const armnn::ComparisonDescriptor& descriptor,
+ const armnn::TensorShape& shape0,
+ std::vector<InType> values0,
+ float quantScale0,
+ int quantOffset0,
+ const armnn::TensorShape& shape1,
+ std::vector<InType> values1,
+ float quantScale1,
+ int quantOffset1,
+ const armnn::TensorShape& outShape,
+ std::vector<uint8_t> outValues,
+ float outQuantScale,
+ int outQuantOffset)
+{
+ BOOST_ASSERT(shape0.GetNumDimensions() == NumDims);
+ armnn::TensorInfo inputTensorInfo0(shape0, ArmnnInType, quantScale0, quantOffset0);
+
+ BOOST_ASSERT(shape1.GetNumDimensions() == NumDims);
+ armnn::TensorInfo inputTensorInfo1(shape1, ArmnnInType, quantScale1, quantOffset1);
+
+ BOOST_ASSERT(outShape.GetNumDimensions() == NumDims);
+ armnn::TensorInfo outputTensorInfo(outShape, armnn::DataType::Boolean, outQuantScale, outQuantOffset);
+
+ auto input0 = MakeTensor<InType, NumDims>(inputTensorInfo0, values0);
+ auto input1 = MakeTensor<InType, NumDims>(inputTensorInfo1, values1);
+
+ LayerTestResult<uint8_t, NumDims> ret(outputTensorInfo);
+
+ std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
+ std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
+ std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
+
+ armnn::ComparisonQueueDescriptor qDescriptor;
+ qDescriptor.m_Parameters = descriptor;
+
+ armnn::WorkloadInfo info;
+ AddInputToWorkload(qDescriptor, info, inputTensorInfo0, inputHandle0.get());
+ AddInputToWorkload(qDescriptor, info, inputTensorInfo1, inputHandle1.get());
+ AddOutputToWorkload(qDescriptor, info, outputTensorInfo, outputHandle.get());
+
+ std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateComparison(qDescriptor, info);
+
+ inputHandle0->Allocate();
+ inputHandle1->Allocate();
+ outputHandle->Allocate();
+
+ CopyDataToITensorHandle(inputHandle0.get(), input0.origin());
+ CopyDataToITensorHandle(inputHandle1.get(), input1.origin());
+
+ workload->PostAllocationConfigure();
+ ExecuteWorkload(*workload, memoryManager);
+
+ CopyDataFromITensorHandle(ret.output.origin(), outputHandle.get());
+
+ ret.outputExpected = MakeTensor<uint8_t, NumDims>(outputTensorInfo, outValues);
+ ret.compareBoolean = true;
+
+ return ret;
+}
+
+template <std::size_t NumDims,
+ armnn::DataType ArmnnInType,
+ typename InType = armnn::ResolveType<ArmnnInType>>
+LayerTestResult<uint8_t, NumDims> ComparisonTestImpl(
+ armnn::IWorkloadFactory & workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
+ const armnn::ComparisonDescriptor& descriptor,
+ const armnn::TensorShape& shape0,
+ std::vector<InType> values0,
+ const armnn::TensorShape& shape1,
+ std::vector<InType> values1,
+ const armnn::TensorShape outShape,
+ std::vector<uint8_t> outValues,
+ float quantScale = 1.f,
+ int quantOffset = 0)
+{
+ return ComparisonTestImpl<NumDims, ArmnnInType>(
+ workloadFactory,
+ memoryManager,
+ descriptor,
+ shape0,
+ values0,
+ quantScale,
+ quantOffset,
+ shape1,
+ values1,
+ quantScale,
+ quantOffset,
+ outShape,
+ outValues,
+ quantScale,
+ quantOffset);
+}
+
+template<typename TestData>
+std::vector<uint8_t> GetExpectedOutputData(const TestData& testData, armnn::ComparisonOperation operation)
+{
+ switch (operation)
+ {
+ case armnn::ComparisonOperation::Equal:
+ return testData.m_OutputEqual;
+ case armnn::ComparisonOperation::Greater:
+ return testData.m_OutputGreater;
+ case armnn::ComparisonOperation::GreaterOrEqual:
+ return testData.m_OutputGreaterOrEqual;
+ case armnn::ComparisonOperation::Less:
+ return testData.m_OutputLess;
+ case armnn::ComparisonOperation::LessOrEqual:
+ return testData.m_OutputLessOrEqual;
+ case armnn::ComparisonOperation::NotEqual:
+ default:
+ return testData.m_OutputNotEqual;
+ }
+}
+
+template<armnn::DataType ArmnnInType, typename TestData>
+LayerTestResult<uint8_t, 4> ComparisonTestImpl(armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+ const TestData& testData,
+ armnn::ComparisonOperation operation,
+ float quantScale = 1.f,
+ int quantOffset = 0)
+{
+ using T = armnn::ResolveType<ArmnnInType>;
+
+ std::vector<T> inputData0 = QuantizedVector<T>(quantScale, quantOffset, testData.m_InputData0);
+ std::vector<T> inputData1 = QuantizedVector<T>(quantScale, quantOffset, testData.m_InputData1);
+
+ return ComparisonTestImpl<4, ArmnnInType>(
+ workloadFactory,
+ memoryManager,
+ armnn::ComparisonDescriptor(operation),
+ testData.m_InputShape0,
+ inputData0,
+ testData.m_InputShape1,
+ inputData1,
+ testData.m_OutputShape,
+ GetExpectedOutputData(testData, operation),
+ quantScale,
+ quantOffset);
+}
+
+class ComparisonTestData
+{
+public:
+ ComparisonTestData() = default;
+ virtual ~ComparisonTestData() = default;
+
+ armnn::TensorShape m_InputShape0;
+ armnn::TensorShape m_InputShape1;
+ armnn::TensorShape m_OutputShape;
+
+ std::vector<float> m_InputData0;
+ std::vector<float> m_InputData1;
+
+ std::vector<uint8_t> m_OutputEqual;
+ std::vector<uint8_t> m_OutputGreater;
+ std::vector<uint8_t> m_OutputGreaterOrEqual;
+ std::vector<uint8_t> m_OutputLess;
+ std::vector<uint8_t> m_OutputLessOrEqual;
+ std::vector<uint8_t> m_OutputNotEqual;
+};
+
+class SimpleTestData : public ComparisonTestData
+{
+public:
+ SimpleTestData() : ComparisonTestData()
+ {
+ m_InputShape0 = { 2, 2, 2, 2 };
+
+ m_InputShape1 = m_InputShape0;
+ m_OutputShape = m_InputShape0;
+
+ m_InputData0 =
+ {
+ 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
+ 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
+ };
+
+ m_InputData1 =
+ {
+ 1.f, 1.f, 1.f, 1.f, 3.f, 3.f, 3.f, 3.f,
+ 5.f, 5.f, 5.f, 5.f, 4.f, 4.f, 4.f, 4.f
+ };
+
+ m_OutputEqual =
+ {
+ 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 1
+ };
+
+ m_OutputGreater =
+ {
+ 0, 0, 0, 0, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0
+ };
+
+ m_OutputGreaterOrEqual =
+ {
+ 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 1, 1, 1, 1
+ };
+
+ m_OutputLess =
+ {
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0
+ };
+
+ m_OutputLessOrEqual =
+ {
+ 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1
+ };
+
+ m_OutputNotEqual =
+ {
+ 0, 0, 0, 0, 1, 1, 1, 1,
+ 1, 1, 1, 1, 0, 0, 0, 0
+ };
+ }
+};
+
+class Broadcast1ElementTestData : public ComparisonTestData
+{
+public:
+ Broadcast1ElementTestData() : ComparisonTestData()
+ {
+ m_InputShape0 = { 1, 2, 2, 2 };
+ m_InputShape1 = { 1, 1, 1, 1 };
+
+ m_OutputShape = m_InputShape0;
+
+ m_InputData0 = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
+ m_InputData1 = { 3.f };
+
+ m_OutputEqual = { 0, 0, 1, 0, 0, 0, 0, 0 };
+ m_OutputGreater = { 0, 0, 0, 1, 1, 1, 1, 1 };
+ m_OutputGreaterOrEqual = { 0, 0, 1, 1, 1, 1, 1, 1 };
+ m_OutputLess = { 1, 1, 0, 0, 0, 0, 0, 0 };
+ m_OutputLessOrEqual = { 1, 1, 1, 0, 0, 0, 0, 0 };
+ m_OutputNotEqual = { 1, 1, 0, 1, 1, 1, 1, 1 };
+ }
+};
+
+class Broadcast1dVectorTestData : public ComparisonTestData
+{
+public:
+ Broadcast1dVectorTestData() : ComparisonTestData()
+ {
+ m_InputShape0 = { 1, 2, 2, 3 };
+ m_InputShape1 = { 1, 1, 1, 3 };
+
+ m_OutputShape = m_InputShape0;
+
+ m_InputData0 =
+ {
+ 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
+ 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
+ };
+
+ m_InputData1 = { 4.f, 5.f, 6.f };
+
+ m_OutputEqual =
+ {
+ 0, 0, 0, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0
+ };
+
+ m_OutputGreater =
+ {
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1
+ };
+
+ m_OutputGreaterOrEqual =
+ {
+ 0, 0, 0, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1
+ };
+
+ m_OutputLess =
+ {
+ 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0
+ };
+
+ m_OutputLessOrEqual =
+ {
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0
+ };
+
+ m_OutputNotEqual =
+ {
+ 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1
+ };
+ }
+};
+
+static SimpleTestData s_SimpleTestData;
+static Broadcast1ElementTestData s_Broadcast1ElementTestData;
+static Broadcast1dVectorTestData s_Broadcast1dVectorTestData;
+
+} // anonymous namespace
+
+// Equal
+LayerTestResult<uint8_t, 4> EqualSimpleTest(armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::Equal);
+}
+
+LayerTestResult<uint8_t, 4> EqualBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::Equal);
+}
+
+LayerTestResult<uint8_t, 4> EqualBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::Equal);
+}
+
+LayerTestResult<uint8_t, 4> EqualSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::Equal);
+}
+
+LayerTestResult<uint8_t, 4> EqualBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::Equal);
+}
+
+LayerTestResult<uint8_t, 4> EqualBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::Equal);
+}
+
+LayerTestResult<uint8_t, 4> EqualSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::Equal);
+}
+
+LayerTestResult<uint8_t, 4> EqualBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::Equal);
+}
+
+LayerTestResult<uint8_t, 4> EqualBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::Equal);
+}
+
+// Greater
+LayerTestResult<uint8_t, 4> GreaterSimpleTest(armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::Greater);
+}
+
+LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::Greater);
+}
+
+LayerTestResult<uint8_t, 4> GreaterBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::Greater);
+}
+
+LayerTestResult<uint8_t, 4> GreaterSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::Greater);
+}
+
+LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::Greater);
+}
+
+LayerTestResult<uint8_t, 4> GreaterBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::Greater);
+}
+
+LayerTestResult<uint8_t, 4> GreaterSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::Greater);
+}
+
+LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::Greater);
+}
+
+LayerTestResult<uint8_t, 4> GreaterBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::Greater);
+}
+
+// GreaterOrEqual
+LayerTestResult<uint8_t, 4> GreaterOrEqualSimpleTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::GreaterOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::GreaterOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::GreaterOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::GreaterOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::GreaterOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::GreaterOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::GreaterOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::GreaterOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::GreaterOrEqual);
+}
+
+// Less
+LayerTestResult<uint8_t, 4> LessSimpleTest(armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::Less);
+}
+
+LayerTestResult<uint8_t, 4> LessBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::Less);
+}
+
+LayerTestResult<uint8_t, 4> LessBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::Less);
+}
+
+LayerTestResult<uint8_t, 4> LessSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::Less);
+}
+
+LayerTestResult<uint8_t, 4> LessBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::Less);
+}
+
+LayerTestResult<uint8_t, 4> LessBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::Less);
+}
+
+LayerTestResult<uint8_t, 4> LessSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::Less);
+}
+
+LayerTestResult<uint8_t, 4> LessBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::Less);
+}
+
+LayerTestResult<uint8_t, 4> LessBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::Less);
+}
+
+// LessOrEqual
+LayerTestResult<uint8_t, 4> LessOrEqualSimpleTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::LessOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::LessOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::LessOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> LessOrEqualSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::LessOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::LessOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::LessOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> LessOrEqualSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::LessOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::LessOrEqual);
+}
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::LessOrEqual);
+}
+
+// NotEqual
+LayerTestResult<uint8_t, 4> NotEqualSimpleTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::NotEqual);
+}
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::NotEqual);
+}
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float32>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::NotEqual);
+}
+
+LayerTestResult<uint8_t, 4> NotEqualSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::NotEqual);
+}
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::NotEqual);
+}
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::Float16>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::NotEqual);
+}
+
+LayerTestResult<uint8_t, 4> NotEqualSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_SimpleTestData,
+ armnn::ComparisonOperation::NotEqual);
+}
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1ElementTestData,
+ armnn::ComparisonOperation::NotEqual);
+}
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
+{
+ return ComparisonTestImpl<armnn::DataType::QuantisedAsymm8>(
+ workloadFactory,
+ memoryManager,
+ s_Broadcast1dVectorTestData,
+ armnn::ComparisonOperation::NotEqual);
+}
diff --git a/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp
index 6ce9b30..84928fa 100644
--- a/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp
+++ b/src/backends/backendsCommon/test/layerTests/ComparisonTestImpl.hpp
@@ -7,120 +7,227 @@
#include "LayerTestResult.hpp"
-#include <armnn/ArmNN.hpp>
-
-#include <ResolveType.hpp>
-
#include <backendsCommon/IBackendInternal.hpp>
-#include <backendsCommon/Workload.hpp>
-#include <backendsCommon/WorkloadData.hpp>
#include <backendsCommon/WorkloadFactory.hpp>
-#include <backendsCommon/test/TensorCopyUtils.hpp>
-#include <backendsCommon/test/WorkloadTestUtils.hpp>
+// Equal
+LayerTestResult<uint8_t, 4> EqualSimpleTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-#include <test/TensorHelpers.hpp>
+LayerTestResult<uint8_t, 4> EqualBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-template <std::size_t NumDims,
- armnn::DataType ArmnnInType,
- typename InType = armnn::ResolveType<ArmnnInType>>
-LayerTestResult<uint8_t, NumDims> ComparisonTestImpl(
- armnn::IWorkloadFactory & workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
- const armnn::ComparisonDescriptor& descriptor,
- const unsigned int shape0[NumDims],
- std::vector<InType> values0,
- float quantScale0,
- int quantOffset0,
- const unsigned int shape1[NumDims],
- std::vector<InType> values1,
- float quantScale1,
- int quantOffset1,
- const unsigned int outShape[NumDims],
- std::vector<uint8_t> outValues,
- float outQuantScale,
- int outQuantOffset)
-{
- armnn::TensorInfo inputTensorInfo0{NumDims, shape0, ArmnnInType};
- armnn::TensorInfo inputTensorInfo1{NumDims, shape1, ArmnnInType};
- armnn::TensorInfo outputTensorInfo{NumDims, outShape, armnn::DataType::Boolean};
+LayerTestResult<uint8_t, 4> EqualBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- auto input0 = MakeTensor<InType, NumDims>(inputTensorInfo0, values0);
- auto input1 = MakeTensor<InType, NumDims>(inputTensorInfo1, values1);
+LayerTestResult<uint8_t, 4> EqualSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- inputTensorInfo0.SetQuantizationScale(quantScale0);
- inputTensorInfo0.SetQuantizationOffset(quantOffset0);
+LayerTestResult<uint8_t, 4> EqualBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- inputTensorInfo1.SetQuantizationScale(quantScale1);
- inputTensorInfo1.SetQuantizationOffset(quantOffset1);
+LayerTestResult<uint8_t, 4> EqualBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- outputTensorInfo.SetQuantizationScale(outQuantScale);
- outputTensorInfo.SetQuantizationOffset(outQuantOffset);
+LayerTestResult<uint8_t, 4> EqualSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- LayerTestResult<uint8_t, NumDims> ret(outputTensorInfo);
+LayerTestResult<uint8_t, 4> EqualBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
- std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
- std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
+LayerTestResult<uint8_t, 4> EqualBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- armnn::ComparisonQueueDescriptor qDescriptor;
- qDescriptor.m_Parameters = descriptor;
+// Greater
+LayerTestResult<uint8_t, 4> GreaterSimpleTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- armnn::WorkloadInfo info;
- AddInputToWorkload(qDescriptor, info, inputTensorInfo0, inputHandle0.get());
- AddInputToWorkload(qDescriptor, info, inputTensorInfo1, inputHandle1.get());
- AddOutputToWorkload(qDescriptor, info, outputTensorInfo, outputHandle.get());
+LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateComparison(qDescriptor, info);
+LayerTestResult<uint8_t, 4> GreaterBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- inputHandle0->Allocate();
- inputHandle1->Allocate();
- outputHandle->Allocate();
+LayerTestResult<uint8_t, 4> GreaterSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- CopyDataToITensorHandle(inputHandle0.get(), input0.origin());
- CopyDataToITensorHandle(inputHandle1.get(), input1.origin());
+LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- workload->PostAllocationConfigure();
- ExecuteWorkload(*workload, memoryManager);
+LayerTestResult<uint8_t, 4> GreaterBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- CopyDataFromITensorHandle(ret.output.origin(), outputHandle.get());
+LayerTestResult<uint8_t, 4> GreaterSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- ret.outputExpected = MakeTensor<uint8_t, NumDims>(outputTensorInfo, outValues);
- ret.compareBoolean = true;
+LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
- return ret;
-}
+LayerTestResult<uint8_t, 4> GreaterBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-template <std::size_t NumDims,
- armnn::DataType ArmnnInType,
- typename InType = armnn::ResolveType<ArmnnInType>>
-LayerTestResult<uint8_t, NumDims> ComparisonTestImpl(
- armnn::IWorkloadFactory & workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
- const armnn::ComparisonDescriptor& descriptor,
- const unsigned int shape0[NumDims],
- std::vector<InType> values0,
- const unsigned int shape1[NumDims],
- std::vector<InType> values1,
- const unsigned int outShape[NumDims],
- std::vector<uint8_t> outValues,
- float qScale = 10.f,
- int qOffset = 0)
-{
- return ComparisonTestImpl<NumDims, ArmnnInType>(
- workloadFactory,
- memoryManager,
- descriptor,
- shape0,
- values0,
- qScale,
- qOffset,
- shape1,
- values1,
- qScale,
- qOffset,
- outShape,
- outValues,
- qScale,
- qOffset);
-}
+// GreaterOrEqual
+LayerTestResult<uint8_t, 4> GreaterOrEqualSimpleTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> GreaterOrEqualBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+// Less
+LayerTestResult<uint8_t, 4> LessSimpleTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+// LessOrEqual
+LayerTestResult<uint8_t, 4> LessOrEqualSimpleTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessOrEqualSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessOrEqualSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> LessOrEqualBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+// NotEqual
+LayerTestResult<uint8_t, 4> NotEqualSimpleTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1ElementTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1dVectorTest(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> NotEqualSimpleFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1ElementFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1dVectorFloat16Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> NotEqualSimpleUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1ElementUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
+
+LayerTestResult<uint8_t, 4> NotEqualBroadcast1dVectorUint8Test(
+ armnn::IWorkloadFactory& workloadFactory,
+ const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
diff --git a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp
deleted file mode 100644
index a3d2b27..0000000
--- a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "EqualTestImpl.hpp"
-
-#include "ComparisonTestImpl.hpp"
-
-#include <Half.hpp>
-
-LayerTestResult<uint8_t, 4> EqualSimpleTest(armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- const unsigned int width = 2u;
- const unsigned int height = 2u;
- const unsigned int channelCount = 2u;
- const unsigned int batchSize = 2u;
-
- unsigned int shape[] = { batchSize, channelCount, height, width };
-
- std::vector<float> input0 =
- {
- 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
- 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
- };
-
- std::vector<float> input1({ 1, 1, 1, 1, 3, 3, 3, 3,
- 5, 5, 5, 5, 4, 4, 4, 4 });
-
- std::vector<uint8_t> output({ 1, 1, 1, 1, 0, 0, 0, 0,
- 0, 0, 0, 0, 1, 1, 1, 1 });
-
- return ComparisonTestImpl<4, armnn::DataType::Float32>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
- shape,
- input0,
- shape,
- input1,
- shape,
- output);
-}
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1ElementTest(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- unsigned int shape0[] = { 1, 2, 2, 2 };
- std::vector<float> input0({ 1, 2, 3, 4, 5, 6, 7, 8});
-
- unsigned int shape1[] = { 1, 1, 1, 1 };
- std::vector<float> input1({ 1 });
-
- std::vector<uint8_t> output({ 1, 0, 0, 0, 0, 0, 0, 0});
-
- return ComparisonTestImpl<4, armnn::DataType::Float32>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorTest(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- const unsigned int shape0[] = { 1, 2, 2, 3 };
- const unsigned int shape1[] = { 1, 1, 1, 3 };
-
- std::vector<float> input0({ 1, 2, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, 12 });
-
- std::vector<float> input1({ 1, 2, 3});
-
- std::vector<uint8_t> output({ 1, 1, 1, 0, 0, 0,
- 0, 0, 0, 0, 0, 0 });
-
- return ComparisonTestImpl<4, armnn::DataType::Float32>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> EqualFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- using namespace half_float::literal;
-
- unsigned int shape[] = { 2, 2, 2, 2 };
-
- // See dequantized values to the right.
- std::vector<armnn::Half> input0({ 1._h, 1._h, 1._h, 1._h, 6._h, 6._h, 6._h, 6._h,
- 3._h, 3._h, 3._h, 3._h, 7._h, 7._h, 7._h, 7._h });
-
- std::vector<armnn::Half> input1({ 2._h, 2._h, 2._h, 2._h, 6._h, 6._h, 6._h, 6._h,
- 3._h, 3._h, 3._h, 3._h, 5._h, 5._h, 5._h, 5._h });
-
- std::vector<uint8_t> output({ 0, 0, 0, 0, 1, 1, 1, 1,
- 1, 1, 1, 1, 0, 0, 0, 0 });
-
- return ComparisonTestImpl<4, armnn::DataType::Float16>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
- shape,
- input0,
- shape,
- input1,
- shape,
- output);
-}
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1ElementFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- using namespace half_float::literal;
-
- const unsigned int shape0[] = { 1, 2, 2, 3 };
- const unsigned int shape1[] = { 1, 1, 1, 1 };
-
- std::vector<armnn::Half> input0({ 1._h, 2._h, 3._h, 4._h, 5._h, 6._h,
- 7._h, 8._h, 9._h, 10._h, 11._h, 12._h });
-
- std::vector<armnn::Half> input1({ 1._h });
-
- std::vector<uint8_t> output({ 1, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0 });
-
- return ComparisonTestImpl<4, armnn::DataType::Float16>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- using namespace half_float::literal;
-
- const unsigned int shape0[] = { 1, 2, 2, 3 };
- const unsigned int shape1[] = { 1, 1, 1, 3 };
-
- std::vector<armnn::Half> input0({ 1._h, 2._h, 3._h, 4._h, 5._h, 6._h,
- 7._h, 8._h, 9._h, 10._h, 11._h, 12._h });
-
- std::vector<armnn::Half> input1({ 1._h, 1._h, 3._h });
-
- std::vector<uint8_t> output({ 1, 0, 1, 0, 0, 0,
- 0, 0, 0, 0, 0, 0 });
-
- return ComparisonTestImpl<4, armnn::DataType::Float16>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> EqualUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- unsigned int shape[] = { 2, 2, 2, 2 };
-
- // See dequantized values to the right.
- std::vector<uint8_t> input0({ 1, 1, 1, 1, 6, 6, 6, 6,
- 3, 3, 3, 3, 7, 7, 7, 7 });
-
- std::vector<uint8_t> input1({ 2, 2, 2, 2, 6, 6, 6, 6,
- 3, 3, 3, 3, 5, 5, 5, 5 });
-
- std::vector<uint8_t> output({ 0, 0, 0, 0, 1, 1, 1, 1,
- 1, 1, 1, 1, 0, 0, 0, 0 });
-
- return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
- shape,
- input0,
- shape,
- input1,
- shape,
- output);
-}
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1ElementUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- const unsigned int shape0[] = { 1, 2, 2, 3 };
- const unsigned int shape1[] = { 1, 1, 1, 1 };
-
- std::vector<uint8_t> input0({ 1, 2, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, 12 });
-
- std::vector<uint8_t> input1({ 1 });
-
- std::vector<uint8_t> output({ 1, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0 });
-
- return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- const unsigned int shape0[] = { 1, 2, 2, 3 };
- const unsigned int shape1[] = { 1, 1, 1, 3 };
-
- std::vector<uint8_t> input0({ 1, 2, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, 12 });
-
- std::vector<uint8_t> input1({ 1, 1, 3});
-
- std::vector<uint8_t> output({ 1, 0, 1, 0, 0, 0,
- 0, 0, 0, 0, 0, 0 });
-
- return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Equal),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
diff --git a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/EqualTestImpl.hpp
deleted file mode 100644
index 3ff07ba..0000000
--- a/src/backends/backendsCommon/test/layerTests/EqualTestImpl.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#pragma once
-
-#include "LayerTestResult.hpp"
-
-#include <backendsCommon/IBackendInternal.hpp>
-#include <backendsCommon/WorkloadFactory.hpp>
-
-LayerTestResult<uint8_t, 4> EqualSimpleTest(armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1ElementTest(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorTest(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> EqualFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1ElementFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> EqualUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1ElementUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
diff --git a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp
deleted file mode 100644
index 271bc23..0000000
--- a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.cpp
+++ /dev/null
@@ -1,314 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "GreaterTestImpl.hpp"
-
-#include "ComparisonTestImpl.hpp"
-
-#include <Half.hpp>
-
-LayerTestResult<uint8_t, 4> GreaterSimpleTest(armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- const unsigned int width = 2u;
- const unsigned int height = 2u;
- const unsigned int channelCount = 2u;
- const unsigned int batchSize = 2u;
-
- unsigned int shape[] = { batchSize, channelCount, height, width };
-
- std::vector<float> input0 =
- {
- 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
- 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
- };
-
- std::vector<float> input1 =
- {
- 1.f, 1.f, 1.f, 1.f, 3.f, 3.f, 3.f, 3.f,
- 5.f, 5.f, 5.f, 5.f, 4.f, 4.f, 4.f, 4.f
- };
-
- std::vector<uint8_t> output =
- {
- 0, 0, 0, 0, 1, 1, 1, 1,
- 0, 0, 0, 0, 0, 0, 0, 0
- };
-
- return ComparisonTestImpl<4, armnn::DataType::Float32>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
- shape,
- input0,
- shape,
- input1,
- shape,
- output);
-}
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementTest(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- unsigned int shape0[] = { 1, 2, 2, 2 };
- unsigned int shape1[] = { 1, 1, 1, 1 };
-
- std::vector<float> input0 = { 1, 2, 3, 4, 5, 6, 7, 8};
- std::vector<float> input1 = { 1 };
-
- std::vector<uint8_t> output = { 0, 1, 1, 1, 1, 1, 1, 1};
-
- return ComparisonTestImpl<4, armnn::DataType::Float32>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorTest(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- const unsigned int shape0[] = { 1, 2, 2, 3 };
- const unsigned int shape1[] = { 1, 1, 1, 3 };
-
- std::vector<float> input0 =
- {
- 1.0f, 2.9f, 2.1f, 4.0f, 5.0f, 6.0f,
- 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f
- };
-
- std::vector<float> input1 = { 1.f, 3.f, 2.f };
-
- std::vector<uint8_t> output =
- {
- 0, 0, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1
- };
-
- return ComparisonTestImpl<4, armnn::DataType::Float32>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> GreaterFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- using namespace half_float::literal;
-
- const unsigned int width = 2u;
- const unsigned int height = 2u;
- const unsigned int channelCount = 2u;
- const unsigned int batchSize = 2u;
-
- unsigned int shape[] = { batchSize, channelCount, height, width };
-
- std::vector<armnn::Half> input0 =
- {
- 1._h, 1._h, 1._h, 1._h, 5._h, 5._h, 5._h, 5._h,
- 3._h, 3._h, 3._h, 3._h, 4._h, 4._h, 4._h, 4._h
- };
-
- std::vector<armnn::Half> input1 =
- {
- 1._h, 1._h, 1._h, 1._h, 3._h, 3._h, 3._h, 3._h,
- 5._h, 5._h, 5._h, 5._h, 4._h, 4._h, 4._h, 4._h
- };
-
- std::vector<uint8_t> output =
- {
- 0, 0, 0, 0, 1, 1, 1, 1,
- 0, 0, 0, 0, 0, 0, 0, 0
- };
-
- return ComparisonTestImpl<4,armnn::DataType::Float16>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
- shape,
- input0,
- shape,
- input1,
- shape,
- output);
-}
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- using namespace half_float::literal;
-
- unsigned int shape0[] = { 1, 2, 2, 2 };
- unsigned int shape1[] = { 1, 1, 1, 1 };
-
- std::vector<armnn::Half> input0 = { 1._h, 2._h, 3._h, 4._h, 5._h, 6._h, 7._h, 8._h };
- std::vector<armnn::Half> input1 = { 1._h };
-
- std::vector<uint8_t> output = { 0, 1, 1, 1, 1, 1, 1, 1};
-
- return ComparisonTestImpl<4, armnn::DataType::Float16>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- using namespace half_float::literal;
-
- const unsigned int shape0[] = { 1, 2, 2, 3 };
- const unsigned int shape1[] = { 1, 1, 1, 3 };
-
- std::vector<armnn::Half> input0 =
- {
- 1.0_h, 2.9_h, 2.1_h, 4.0_h, 5.0_h, 6.0_h,
- 7.0_h, 8.0_h, 9.0_h, 10.0_h, 11.0_h, 12.0_h
- };
-
- std::vector<armnn::Half> input1 = { 1._h, 3._h, 2._h };
-
- std::vector<uint8_t> output =
- {
- 0, 0, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1
- };
-
- return ComparisonTestImpl<4, armnn::DataType::Float16>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> GreaterUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- unsigned int shape[] = { 2, 2, 2, 2 };
-
- // See dequantized values to the right.
- std::vector<uint8_t> input0 =
- {
- 1, 1, 1, 1, 6, 6, 6, 6,
- 3, 3, 3, 3, 5, 5, 5, 5
- };
-
- std::vector<uint8_t> input1 =
- {
- 2, 2, 2, 2, 6, 6, 6, 6,
- 2, 2, 2, 2, 5, 5, 5, 5
- };
-
- std::vector<uint8_t> output =
- {
- 0, 0, 0, 0, 0, 0, 0, 0,
- 1, 1, 1, 1, 0, 0, 0, 0
- };
-
- return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
- shape,
- input0,
- shape,
- input1,
- shape,
- output);
-}
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- const unsigned int shape0[] = { 1, 2, 2, 3 };
- const unsigned int shape1[] = { 1, 1, 1, 1 };
-
- std::vector<uint8_t> input0 =
- {
- 1, 2, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, 12
- };
-
- std::vector<uint8_t> input1 = { 1 };
-
- std::vector<uint8_t> output =
- {
- 0, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1
- };
-
- return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
-{
- const unsigned int shape0[] = { 1, 2, 2, 3 };
- const unsigned int shape1[] = { 1, 1, 1, 3 };
-
- std::vector<uint8_t> input0 =
- {
- 1, 2, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, 12
- };
-
- std::vector<uint8_t> input1 = { 1, 1, 3 };
-
- std::vector<uint8_t> output =
- {
- 0, 1, 0, 1, 1, 1,
- 1, 1, 1, 1, 1, 1
- };
-
- return ComparisonTestImpl<4, armnn::DataType::QuantisedAsymm8>(
- workloadFactory,
- memoryManager,
- armnn::ComparisonDescriptor(armnn::ComparisonOperation::Greater),
- shape0,
- input0,
- shape1,
- input1,
- shape0,
- output);
-}
diff --git a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.hpp
deleted file mode 100644
index 060fc28..0000000
--- a/src/backends/backendsCommon/test/layerTests/GreaterTestImpl.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#pragma once
-
-#include "LayerTestResult.hpp"
-
-#include <backendsCommon/IBackendInternal.hpp>
-#include <backendsCommon/WorkloadFactory.hpp>
-
-LayerTestResult<uint8_t, 4> GreaterSimpleTest(armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementTest(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorTest(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> GreaterFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorFloat16Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> GreaterUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
-
-LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorUint8Test(
- armnn::IWorkloadFactory& workloadFactory,
- const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
diff --git a/src/backends/cl/test/ClLayerTests.cpp b/src/backends/cl/test/ClLayerTests.cpp
index 8879928..4e987db 100644
--- a/src/backends/cl/test/ClLayerTests.cpp
+++ b/src/backends/cl/test/ClLayerTests.cpp
@@ -499,12 +499,13 @@
ARMNN_AUTO_TEST_CASE(MinimumBroadcast1DVectorUint8, MinimumBroadcast1DVectorUint8Test)
// Greater
-ARMNN_AUTO_TEST_CASE(SimpleGreater, GreaterSimpleTest)
+ARMNN_AUTO_TEST_CASE(GreaterSimple, GreaterSimpleTest)
ARMNN_AUTO_TEST_CASE(GreaterBroadcast1Element, GreaterBroadcast1ElementTest)
-ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVector, GreaterBroadcast1DVectorTest)
-ARMNN_AUTO_TEST_CASE(GreaterUint8, GreaterUint8Test)
+ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVector, GreaterBroadcast1dVectorTest)
+
+ARMNN_AUTO_TEST_CASE(GreaterSimpleUint8, GreaterSimpleUint8Test)
ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementUint8, GreaterBroadcast1ElementUint8Test)
-ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVectorUint8, GreaterBroadcast1DVectorUint8Test)
+ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVectorUint8, GreaterBroadcast1dVectorUint8Test)
// Softmax
ARMNN_AUTO_TEST_CASE(SimpleSoftmaxBeta1, SimpleSoftmaxTest, 1.0f)
diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp
index 920fb0b..50a2d1d 100644
--- a/src/backends/neon/test/NeonLayerTests.cpp
+++ b/src/backends/neon/test/NeonLayerTests.cpp
@@ -546,12 +546,13 @@
ARMNN_AUTO_TEST_CASE(SimpleFloor, SimpleFloorTest<DataType::Float32>)
// Greater
-ARMNN_AUTO_TEST_CASE(SimpleGreater, GreaterSimpleTest)
+ARMNN_AUTO_TEST_CASE(GreaterSimple, GreaterSimpleTest)
ARMNN_AUTO_TEST_CASE(GreaterBroadcast1Element, GreaterBroadcast1ElementTest)
-ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVector, GreaterBroadcast1DVectorTest)
-ARMNN_AUTO_TEST_CASE(GreaterUint8, GreaterUint8Test)
+ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVector, GreaterBroadcast1dVectorTest)
+
+ARMNN_AUTO_TEST_CASE(GreaterSimpleUint8, GreaterSimpleUint8Test)
ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementUint8, GreaterBroadcast1ElementUint8Test)
-ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVectorUint8, GreaterBroadcast1DVectorUint8Test)
+ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVectorUint8, GreaterBroadcast1dVectorUint8Test)
// Reshape
ARMNN_AUTO_TEST_CASE(SimpleReshapeFloat32, SimpleReshapeTest<armnn::DataType::Float32>)
diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp
index 5de9b75..1b284c3 100644
--- a/src/backends/reference/test/RefLayerTests.cpp
+++ b/src/backends/reference/test/RefLayerTests.cpp
@@ -543,26 +543,82 @@
ARMNN_AUTO_TEST_CASE(DivisionInt16Broadcast1DVector, DivisionBroadcast1DVectorInt16Test)
// Equal
-ARMNN_AUTO_TEST_CASE(SimpleEqual, EqualSimpleTest)
+ARMNN_AUTO_TEST_CASE(EqualSimple, EqualSimpleTest)
ARMNN_AUTO_TEST_CASE(EqualBroadcast1Element, EqualBroadcast1ElementTest)
-ARMNN_AUTO_TEST_CASE(EqualBroadcast1DVector, EqualBroadcast1DVectorTest)
-ARMNN_AUTO_TEST_CASE(EqualFloat16, EqualFloat16Test)
+ARMNN_AUTO_TEST_CASE(EqualBroadcast1dVector, EqualBroadcast1dVectorTest)
+
+ARMNN_AUTO_TEST_CASE(EqualSimpleFloat16, EqualSimpleFloat16Test)
ARMNN_AUTO_TEST_CASE(EqualBroadcast1ElementFloat16, EqualBroadcast1ElementFloat16Test)
-ARMNN_AUTO_TEST_CASE(EqualBroadcast1DVectorFloat16, EqualBroadcast1DVectorFloat16Test)
-ARMNN_AUTO_TEST_CASE(EqualUint8, EqualUint8Test)
+ARMNN_AUTO_TEST_CASE(EqualBroadcast1dVectorFloat16, EqualBroadcast1dVectorFloat16Test)
+
+ARMNN_AUTO_TEST_CASE(EqualSimpleUint8, EqualSimpleUint8Test)
ARMNN_AUTO_TEST_CASE(EqualBroadcast1ElementUint8, EqualBroadcast1ElementUint8Test)
-ARMNN_AUTO_TEST_CASE(EqualBroadcast1DVectorUint8, EqualBroadcast1DVectorUint8Test)
+ARMNN_AUTO_TEST_CASE(EqualBroadcast1dVectorUint8, EqualBroadcast1dVectorUint8Test)
// Greater
-ARMNN_AUTO_TEST_CASE(SimpleGreater, GreaterSimpleTest)
+ARMNN_AUTO_TEST_CASE(GreaterSimple, GreaterSimpleTest)
ARMNN_AUTO_TEST_CASE(GreaterBroadcast1Element, GreaterBroadcast1ElementTest)
-ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVector, GreaterBroadcast1DVectorTest)
-ARMNN_AUTO_TEST_CASE(GreaterUint8, GreaterUint8Test)
-ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementUint8, GreaterBroadcast1ElementUint8Test)
-ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVectorUint8, GreaterBroadcast1DVectorUint8Test)
-ARMNN_AUTO_TEST_CASE(GreaterFloat16, GreaterFloat16Test)
+ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVector, GreaterBroadcast1dVectorTest)
+
+ARMNN_AUTO_TEST_CASE(GreaterSimpleFloat16, GreaterSimpleFloat16Test)
ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementFloat16, GreaterBroadcast1ElementFloat16Test)
-ARMNN_AUTO_TEST_CASE(GreaterBroadcast1DVectorFloat16, GreaterBroadcast1DVectorFloat16Test)
+ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVectorFloat16, GreaterBroadcast1dVectorFloat16Test)
+
+ARMNN_AUTO_TEST_CASE(GreaterSimpleUint8, GreaterSimpleUint8Test)
+ARMNN_AUTO_TEST_CASE(GreaterBroadcast1ElementUint8, GreaterBroadcast1ElementUint8Test)
+ARMNN_AUTO_TEST_CASE(GreaterBroadcast1dVectorUint8, GreaterBroadcast1dVectorUint8Test)
+
+// GreaterOrEqual
+ARMNN_AUTO_TEST_CASE(GreaterOrEqualSimple, GreaterOrEqualSimpleTest)
+ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1Element, GreaterOrEqualBroadcast1ElementTest)
+ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1dVector, GreaterOrEqualBroadcast1dVectorTest)
+
+ARMNN_AUTO_TEST_CASE(GreaterOrEqualSimpleFloat16, GreaterOrEqualSimpleFloat16Test)
+ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1ElementFloat16, GreaterOrEqualBroadcast1ElementFloat16Test)
+ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1dVectorFloat16, GreaterOrEqualBroadcast1dVectorFloat16Test)
+
+ARMNN_AUTO_TEST_CASE(GreaterOrEqualSimpleUint8, GreaterOrEqualSimpleUint8Test)
+ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1ElementUint8, GreaterOrEqualBroadcast1ElementUint8Test)
+ARMNN_AUTO_TEST_CASE(GreaterOrEqualBroadcast1dVectorUint8, GreaterOrEqualBroadcast1dVectorUint8Test)
+
+// Less
+ARMNN_AUTO_TEST_CASE(LessSimple, LessSimpleTest)
+ARMNN_AUTO_TEST_CASE(LessBroadcast1Element, LessBroadcast1ElementTest)
+ARMNN_AUTO_TEST_CASE(LessBroadcast1dVector, LessBroadcast1dVectorTest)
+
+ARMNN_AUTO_TEST_CASE(LessSimpleFloat16, LessSimpleFloat16Test)
+ARMNN_AUTO_TEST_CASE(LessBroadcast1ElementFloat16, LessBroadcast1ElementFloat16Test)
+ARMNN_AUTO_TEST_CASE(LessBroadcast1dVectorFloat16, LessBroadcast1dVectorFloat16Test)
+
+ARMNN_AUTO_TEST_CASE(LessSimpleUint8, LessSimpleUint8Test)
+ARMNN_AUTO_TEST_CASE(LessBroadcast1ElementUint8, LessBroadcast1ElementUint8Test)
+ARMNN_AUTO_TEST_CASE(LessBroadcast1dVectorUint8, LessBroadcast1dVectorUint8Test)
+
+// GreaterOrEqual
+ARMNN_AUTO_TEST_CASE(LessOrEqualSimple, LessOrEqualSimpleTest)
+ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1Element, LessOrEqualBroadcast1ElementTest)
+ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1dVector, LessOrEqualBroadcast1dVectorTest)
+
+ARMNN_AUTO_TEST_CASE(LessOrEqualSimpleFloat16, LessOrEqualSimpleFloat16Test)
+ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1ElementFloat16, LessOrEqualBroadcast1ElementFloat16Test)
+ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1dVectorFloat16, LessOrEqualBroadcast1dVectorFloat16Test)
+
+ARMNN_AUTO_TEST_CASE(LessOrEqualSimpleUint8, LessOrEqualSimpleUint8Test)
+ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1ElementUint8, LessOrEqualBroadcast1ElementUint8Test)
+ARMNN_AUTO_TEST_CASE(LessOrEqualBroadcast1dVectorUint8, LessOrEqualBroadcast1dVectorUint8Test)
+
+// NotEqual
+ARMNN_AUTO_TEST_CASE(NotEqualSimple, NotEqualSimpleTest)
+ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1Element, NotEqualBroadcast1ElementTest)
+ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1dVector, NotEqualBroadcast1dVectorTest)
+
+ARMNN_AUTO_TEST_CASE(NotEqualSimpleFloat16, NotEqualSimpleFloat16Test)
+ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1ElementFloat16, NotEqualBroadcast1ElementFloat16Test)
+ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1dVectorFloat16, NotEqualBroadcast1dVectorFloat16Test)
+
+ARMNN_AUTO_TEST_CASE(NotEqualSimpleUint8, NotEqualSimpleUint8Test)
+ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1ElementUint8, NotEqualBroadcast1ElementUint8Test)
+ARMNN_AUTO_TEST_CASE(NotEqualBroadcast1dVectorUint8, NotEqualBroadcast1dVectorUint8Test)
// Max
ARMNN_AUTO_TEST_CASE(SimpleMaximum, MaximumSimpleTest)