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);