IVGCVSW-5548 Fix delegate ElementwiseUnary tests for CpuAcc/GpuAcc

 * Apply new test suite structure to be able to filter for backends
   For ElementwiseBinary and ElementwiseUnary
 * Add tolerance to data comparison

Signed-off-by: Jan Eilers <jan.eilers@arm.com>
Change-Id: Iccabb68f316c93533e1076da5822ebc199e23739

4 files changed, 425 insertions, 234 deletions

diff --git a/delegate/src/test/Convolution2dTest.cpp b/delegate/src/test/Convolution2dTest.cpp
index 4e9377a24d..f8ee7b1efd 100644
--- a/delegate/src/test/Convolution2dTest.cpp
+++ b/delegate/src/test/Convolution2dTest.cpp
@@ -220,7 +220,7 @@ void Conv2DWithBiasesRelu6Uint8Test(std::vector<armnn::BackendId>& backends)
                                             biasValues);
 }
 
-TEST_SUITE("Convolution2dTest_CpuRef")
+TEST_SUITE("Convolution2dTest_CpuRefTests")
 {
 
 TEST_CASE ("Conv2DWithBiases_Fp32_CpuRef_Test")
@@ -249,7 +249,7 @@ TEST_CASE ("Conv2DWithBiases_Relu6_Uint8_CpuRef_Test")
 
 } //End of TEST_SUITE("Convolution2dTest_CpuRef")
 
-TEST_SUITE("Convolution2dTest_CpuAcc")
+TEST_SUITE("Convolution2dTest_CpuAccTests")
 {
 
 TEST_CASE ("Conv2DWithBiases_Fp32_CpuAcc_Test")
@@ -278,7 +278,7 @@ Conv2DWithBiasesRelu6Uint8Test(backends);
 
 } //End of TEST_SUITE("Convolution2dTest_CpuAcc")
 
-TEST_SUITE("Convolution2dTest_GpuAcc")
+TEST_SUITE("Convolution2dTest_GpuAccTests")
 {
 
 TEST_CASE ("Conv2DWithBiases_Fp32_GpuAcc_Test")
diff --git a/delegate/src/test/ElementwiseBinaryTest.cpp b/delegate/src/test/ElementwiseBinaryTest.cpp
index 2a8c91b2ef..0ae60a296d 100644
--- a/delegate/src/test/ElementwiseBinaryTest.cpp
+++ b/delegate/src/test/ElementwiseBinaryTest.cpp
@@ -657,289 +657,382 @@ void SubUint8Test(std::vector<armnn::BackendId>& backends)
                                    expectedOutputValues, 1.0f, 0);
 }
 
-TEST_SUITE("ElementwiseBinaryTest")
+TEST_SUITE("ElementwiseBinary_GpuAccTests")
 {
 
 TEST_CASE ("ADD_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
     AddFP32Test(backends);
 }
 
-TEST_CASE ("ADD_FP32_CpuAcc_Test")
+TEST_CASE ("ADD_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    AddFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    AddBroadcastTest(backends);
 }
 
-TEST_CASE ("ADD_Broadcast_GpuAcc_Test")
+TEST_CASE ("ADD_Activation_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    AddBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    AddActivationTest(backends);
 }
 
-TEST_CASE ("ADD_Broadcast_CpuAcc_Test")
+TEST_CASE ("ADD_UINT8_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    AddBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    AddUint8Test(backends);
 }
 
-TEST_CASE ("ADD_Activation_GpuAcc_Test")
+TEST_CASE ("DIV_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    AddActivationTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    DivFP32Test(backends);
 }
 
-TEST_CASE ("ADD_Actiation_CpuAcc_Test")
+TEST_CASE ("DIV_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    AddActivationTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    DivBroadcastTest(backends);
 }
 
-TEST_CASE ("ADD_UINT8_GpuAcc_Test")
+TEST_CASE ("DIV_UINT8_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    AddUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    DivUint8Test(backends);
 }
 
-TEST_CASE ("ADD_UINT8_CpuAcc_Test")
+TEST_CASE ("MAX_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    AddUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MaxFP32Test(backends);
 }
 
-TEST_CASE ("DIV_FP32_GpuAcc_Test")
+TEST_CASE ("MAX_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    DivFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MaxBroadcastTest(backends);
 }
 
-TEST_CASE ("DIV_FP32_CpuAcc_Test")
+TEST_CASE ("MAX_UINT8_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    DivFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MaxUint8Test(backends);
 }
 
-TEST_CASE ("DIV_Broadcast_GpuAcc_Test")
+TEST_CASE ("MIN_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    DivBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MinFP32Test(backends);
 }
 
-TEST_CASE ("DIV_Broadcast_CpuAcc_Test")
+TEST_CASE ("MIN_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    DivBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MinBroadcastTest(backends);
 }
 
-TEST_CASE ("DIV_UINT8_GpuAcc_Test")
+TEST_CASE ("MIN_UINT8_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    DivUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MinUint8Test(backends);
 }
 
-TEST_CASE ("DIV_UINT8_CpuAcc_Test")
+TEST_CASE ("MUL_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    DivUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MulFP32Test(backends);
 }
 
-TEST_CASE ("MAX_FP32_GpuAcc_Test")
+TEST_CASE ("MUL_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MaxFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MulBroadcastTest(backends);
 }
 
-TEST_CASE ("MAX_FP32_CpuAcc_Test")
+TEST_CASE ("MUL_Activation_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MaxFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MulActivationTest(backends);
 }
 
-TEST_CASE ("MAX_Broadcast_GpuAcc_Test")
+TEST_CASE ("MUL_UINT8_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MaxBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    MulUint8Test(backends);
 }
 
-TEST_CASE ("MAX_Broadcast_CpuAcc_Test")
+TEST_CASE ("SUB_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MaxBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    SubFP32Test(backends);
 }
 
-TEST_CASE ("MAX_UINT8_GpuAcc_Test")
+TEST_CASE ("SUB_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MaxUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    SubBroadcastTest(backends);
 }
 
-TEST_CASE ("MAX_UINT8_CpuAcc_Test")
+TEST_CASE ("SUB_UINT8_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MaxUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    SubUint8Test(backends);
 }
 
-TEST_CASE ("MIN_FP32_GpuAcc_Test")
+} //TEST_SUITE("ElementwiseBinary_GpuAccTests")
+
+
+
+TEST_SUITE("ElementwiseBinary_CpuAccTests")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MinFP32Test(backends);
+
+TEST_CASE ("ADD_FP32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    AddFP32Test(backends);
 }
 
-TEST_CASE ("MIN_FP32_CpuAcc_Test")
+TEST_CASE ("ADD_Broadcast_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MinFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    AddBroadcastTest(backends);
 }
 
-TEST_CASE ("MIN_Broadcast_GpuAcc_Test")
+TEST_CASE ("ADD_Actiation_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MinBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    AddActivationTest(backends);
 }
 
-TEST_CASE ("MIN_Broadcast_CpuAcc_Test")
+TEST_CASE ("ADD_UINT8_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MinBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    AddUint8Test(backends);
 }
 
-TEST_CASE ("MIN_UINT8_GpuAcc_Test")
+TEST_CASE ("DIV_FP32_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MinUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    DivFP32Test(backends);
 }
 
-TEST_CASE ("MIN_UINT8_CpuAcc_Test")
+TEST_CASE ("DIV_Broadcast_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MinUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    DivBroadcastTest(backends);
 }
 
-TEST_CASE ("MUL_FP32_GpuAcc_Test")
+TEST_CASE ("DIV_UINT8_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MulFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    DivUint8Test(backends);
 }
 
-TEST_CASE ("MUL_FP32_CpuAcc_Test")
+TEST_CASE ("MAX_FP32_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MulFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MaxFP32Test(backends);
 }
 
-TEST_CASE ("MUL_Broadcast_GpuAcc_Test")
+TEST_CASE ("MAX_Broadcast_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MulBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MaxBroadcastTest(backends);
 }
 
-TEST_CASE ("MUL_Broadcast_CpuAcc_Test")
+TEST_CASE ("MAX_UINT8_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MulBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MaxUint8Test(backends);
 }
 
-TEST_CASE ("MUL_Activation_GpuAcc_Test")
+TEST_CASE ("MIN_FP32_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MulActivationTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MinFP32Test(backends);
 }
 
-TEST_CASE ("MUL_Actiation_CpuAcc_Test")
+TEST_CASE ("MIN_Broadcast_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MulActivationTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MinBroadcastTest(backends);
 }
 
-TEST_CASE ("MUL_UINT8_GpuAcc_Test")
+TEST_CASE ("MIN_UINT8_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    MulUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MinUint8Test(backends);
 }
 
-TEST_CASE ("MUL_UINT8_CpuAcc_Test")
+TEST_CASE ("MUL_FP32_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    MulUint8Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MulFP32Test(backends);
 }
 
-TEST_CASE ("SUB_FP32_GpuAcc_Test")
+TEST_CASE ("MUL_Broadcast_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    SubFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MulBroadcastTest(backends);
 }
 
-TEST_CASE ("SUB_FP32_CpuAcc_Test")
+TEST_CASE ("MUL_Actiation_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    SubFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MulActivationTest(backends);
 }
 
-TEST_CASE ("SUB_Broadcast_GpuAcc_Test")
+TEST_CASE ("MUL_UINT8_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    SubBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    MulUint8Test(backends);
+}
+
+TEST_CASE ("SUB_FP32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    SubFP32Test(backends);
 }
 
 TEST_CASE ("SUB_Broadcast_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
     SubBroadcastTest(backends);
 }
 
-TEST_CASE ("SUB_UINT8_GpuAcc_Test")
+TEST_CASE ("SUB_UINT8_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
     SubUint8Test(backends);
 }
 
-TEST_CASE ("SUB_UINT8_CpuAcc_Test")
+} // TEST_SUITE("ElementwiseBinary_CpuAccTests")
+
+
+TEST_SUITE("ElementwiseBinary_CpuRefTests")
+{
+
+TEST_CASE ("ADD_FP32_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    AddFP32Test(backends);
+}
+
+TEST_CASE ("ADD_Broadcast_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    AddBroadcastTest(backends);
+}
+
+TEST_CASE ("ADD_Actiation_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    AddActivationTest(backends);
+}
+
+TEST_CASE ("ADD_UINT8_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    AddUint8Test(backends);
+}
+
+TEST_CASE ("DIV_FP32_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    DivFP32Test(backends);
+}
+
+TEST_CASE ("DIV_Broadcast_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    DivBroadcastTest(backends);
+}
+
+TEST_CASE ("DIV_UINT8_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    DivUint8Test(backends);
+}
+
+TEST_CASE ("MAX_FP32_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MaxFP32Test(backends);
+}
+
+TEST_CASE ("MAX_Broadcast_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MaxBroadcastTest(backends);
+}
+
+TEST_CASE ("MAX_UINT8_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MaxUint8Test(backends);
+}
+
+TEST_CASE ("MIN_FP32_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MinFP32Test(backends);
+}
+
+TEST_CASE ("MIN_Broadcast_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MinBroadcastTest(backends);
+}
+
+TEST_CASE ("MIN_UINT8_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MinUint8Test(backends);
+}
+
+TEST_CASE ("MUL_FP32_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MulFP32Test(backends);
+}
+
+TEST_CASE ("MUL_Broadcast_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MulBroadcastTest(backends);
+}
+
+TEST_CASE ("MUL_Actiation_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MulActivationTest(backends);
+}
+
+TEST_CASE ("MUL_UINT8_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    MulUint8Test(backends);
+}
+
+TEST_CASE ("SUB_FP32_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    SubFP32Test(backends);
+}
+
+TEST_CASE ("SUB_Broadcast_CpuRef_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    SubBroadcastTest(backends);
+}
+
+TEST_CASE ("SUB_UINT8_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
     SubUint8Test(backends);
 }
 
-} // End of TEST_SUITE("ElementwiseBinaryTest")
+} // TEST_SUITE("ElementwiseBinary_CpuRefTests")
 
 } // namespace armnnDelegate
\ No newline at end of file
diff --git a/delegate/src/test/ElementwiseUnaryTest.cpp b/delegate/src/test/ElementwiseUnaryTest.cpp
index c504707c99..012ffde057 100644
--- a/delegate/src/test/ElementwiseUnaryTest.cpp
+++ b/delegate/src/test/ElementwiseUnaryTest.cpp
@@ -19,14 +19,13 @@
 namespace armnnDelegate
 {
 
-TEST_SUITE("ElementwiseUnaryTest")
+TEST_SUITE("ElementwiseUnary_GpuAccTests")
 {
 
 TEST_CASE ("Abs_Float32_GpuAcc_Test")
 {
     // Create the ArmNN Delegate
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                           armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
     // Set input data
     std::vector<float> inputValues
     {
@@ -42,55 +41,119 @@ TEST_CASE ("Abs_Float32_GpuAcc_Test")
     ElementwiseUnaryFP32Test(tflite::BuiltinOperator_ABS, backends, inputValues, expectedOutputValues);
 }
 
-TEST_CASE ("Abs_Float32_CpuAcc_Test")
+TEST_CASE ("Exp_Float32_GpuAcc_Test")
 {
     // Create the ArmNN Delegate
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
     // Set input data
     std::vector<float> inputValues
     {
-        -0.1f, -0.2f, -0.3f,
-        0.1f,  0.2f,  0.3f
+        5.0f, 4.0f,
+        3.0f, 2.0f,
+        1.0f, 1.1f
+    };
+    // Set output data
+    std::vector<float> expectedOutputValues
+    {
+        148.413159102577f, 54.598150033144f,
+        20.085536923188f,  7.389056098931f,
+        2.718281828459f,  3.004166023946f
+    };
+
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_EXP, backends, inputValues, expectedOutputValues);
+}
+
+TEST_CASE ("Neg_Float32_GpuAcc_Test")
+{
+    // Create the ArmNN Delegate
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    // Set input data
+    std::vector<float> inputValues
+    {
+        1.f, 0.f, 3.f,
+        25.f, 64.f, 100.f
+    };
+    // Set output data
+    std::vector<float> expectedOutputValues
+    {
+        -1.f, 0.f, -3.f,
+        -25.f, -64.f, -100.f
+    };
+
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_NEG, backends, inputValues, expectedOutputValues);
+}
+
+TEST_CASE ("Rsqrt_Float32_GpuAcc_Test")
+{
+    // Create the ArmNN Delegate
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    // Set input data
+    std::vector<float> inputValues
+    {
+        1.f, 4.f, 16.f,
+        25.f, 64.f, 100.f
+    };
+    // Set output data
+    std::vector<float> expectedOutputValues
+    {
+        1.f, 0.5f, 0.25f,
+        0.2f, 0.125f, 0.1f
+    };
+
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues);
+}
+
+TEST_CASE ("Sqrt_Float32_GpuAcc_Test")
+{
+    // Create the ArmNN Delegate
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    // Set input data
+    std::vector<float> inputValues
+    {
+        9.0f, 4.25f, 81.9f,
+        0.1f,  0.9f,  169.0f
     };
     // Calculate output data
     std::vector<float> expectedOutputValues(inputValues.size());
     for (unsigned int i = 0; i < inputValues.size(); ++i)
     {
-        expectedOutputValues[i] = std::abs(inputValues[i]);
+        expectedOutputValues[i] = std::sqrt(inputValues[i]);
     }
 
-    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_ABS, backends, inputValues, expectedOutputValues);
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_SQRT, backends, inputValues, expectedOutputValues);
 }
 
-TEST_CASE ("Exp_Float32_GpuAcc_Test")
+} // TEST_SUITE("ElementwiseUnary_GpuAccTests")
+
+
+
+TEST_SUITE("ElementwiseUnary_CpuAccTests")
+{
+
+TEST_CASE ("Abs_Float32_CpuAcc_Test")
 {
     // Create the ArmNN Delegate
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
     // Set input data
     std::vector<float> inputValues
     {
-        5.0f, 4.0f,
-        3.0f, 2.0f,
-        1.0f, 1.1f
+        -0.1f, -0.2f, -0.3f,
+        0.1f,  0.2f,  0.3f
     };
-    // Set output data
-    std::vector<float> expectedOutputValues
+    // Calculate output data
+    std::vector<float> expectedOutputValues(inputValues.size());
+    for (unsigned int i = 0; i < inputValues.size(); ++i)
     {
-        148.413159102577f, 54.598150033144f,
-        20.085536923188f,  7.389056098931f,
-        2.718281828459f,  3.004166023946f
-    };
+        expectedOutputValues[i] = std::abs(inputValues[i]);
+    }
 
-    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_EXP, backends, inputValues, expectedOutputValues);
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_ABS, backends, inputValues, expectedOutputValues);
 }
 
 TEST_CASE ("Exp_Float32_CpuAcc_Test")
 {
     // Create the ArmNN Delegate
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
     // Set input data
     std::vector<float> inputValues
     {
@@ -109,11 +172,10 @@ TEST_CASE ("Exp_Float32_CpuAcc_Test")
     ElementwiseUnaryFP32Test(tflite::BuiltinOperator_EXP, backends, inputValues, expectedOutputValues);
 }
 
-TEST_CASE ("Neg_Float32_GpuAcc_Test")
+TEST_CASE ("Neg_Float32_CpuAcc_Test")
 {
     // Create the ArmNN Delegate
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
     // Set input data
     std::vector<float> inputValues
     {
@@ -130,94 +192,136 @@ TEST_CASE ("Neg_Float32_GpuAcc_Test")
     ElementwiseUnaryFP32Test(tflite::BuiltinOperator_NEG, backends, inputValues, expectedOutputValues);
 }
 
-TEST_CASE ("Neg_Float32_CpuAcc_Test")
+TEST_CASE ("Rsqrt_Float32_CpuAcc_Test")
 {
     // Create the ArmNN Delegate
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
     // Set input data
     std::vector<float> inputValues
     {
-        1.f, 0.f, 3.f,
+        1.f, 4.f, 16.f,
         25.f, 64.f, 100.f
     };
     // Set output data
     std::vector<float> expectedOutputValues
     {
-        -1.f, 0.f, -3.f,
-        -25.f, -64.f, -100.f
+        1.f, 0.5f, 0.25f,
+        0.2f, 0.125f, 0.1f
     };
 
-    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_NEG, backends, inputValues, expectedOutputValues);
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues);
 }
 
-TEST_CASE ("Rsqrt_Float32_GpuAcc_Test")
+TEST_CASE ("Sqrt_Float32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    // Set input data
+    std::vector<float> inputValues
+    {
+        9.0f, 4.25f, 81.9f,
+        0.1f,  0.9f,  169.0f
+    };
+    // Calculate output data
+    std::vector<float> expectedOutputValues(inputValues.size());
+    for (unsigned int i = 0; i < inputValues.size(); ++i)
+    {
+        expectedOutputValues[i] = std::sqrt(inputValues[i]);
+    }
+
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_SQRT, backends, inputValues, expectedOutputValues);
+}
+
+} // TEST_SUITE("ElementwiseUnary_CpuAccTests")
+
+
+TEST_SUITE("ElementwiseUnary_CpuRefTests")
+{
+
+TEST_CASE ("Abs_Float32_CpuRef_Test")
 {
     // Create the ArmNN Delegate
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
     // Set input data
     std::vector<float> inputValues
     {
-        1.f, 4.f, 16.f,
-        25.f, 64.f, 100.f
+        -0.1f, -0.2f, -0.3f,
+        0.1f,  0.2f,  0.3f
+    };
+    // Calculate output data
+    std::vector<float> expectedOutputValues(inputValues.size());
+    for (unsigned int i = 0; i < inputValues.size(); ++i)
+    {
+        expectedOutputValues[i] = std::abs(inputValues[i]);
+    }
+
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_ABS, backends, inputValues, expectedOutputValues);
+}
+
+TEST_CASE ("Exp_Float32_CpuRef_Test")
+{
+    // Create the ArmNN Delegate
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    // Set input data
+    std::vector<float> inputValues
+    {
+        5.0f, 4.0f,
+        3.0f, 2.0f,
+        1.0f, 1.1f
     };
     // Set output data
     std::vector<float> expectedOutputValues
     {
-        1.f, 0.5f, 0.25f,
-        0.2f, 0.125f, 0.1f
+        148.413159102577f, 54.598150033144f,
+        20.085536923188f,  7.389056098931f,
+        2.718281828459f,  3.004166023946f
     };
 
-    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues);
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_EXP, backends, inputValues, expectedOutputValues);
 }
 
-TEST_CASE ("Rsqrt_Float32_CpuAcc_Test")
+TEST_CASE ("Neg_Float32_CpuRef_Test")
 {
     // Create the ArmNN Delegate
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
     // Set input data
     std::vector<float> inputValues
     {
-        1.f, 4.f, 16.f,
+        1.f, 0.f, 3.f,
         25.f, 64.f, 100.f
     };
     // Set output data
     std::vector<float> expectedOutputValues
     {
-        1.f, 0.5f, 0.25f,
-        0.2f, 0.125f, 0.1f
+        -1.f, 0.f, -3.f,
+        -25.f, -64.f, -100.f
     };
 
-    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues);
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_NEG, backends, inputValues, expectedOutputValues);
 }
 
-TEST_CASE ("Sqrt_Float32_GpuAcc_Test")
+TEST_CASE ("Rsqrt_Float32_CpuRef_Test")
 {
     // Create the ArmNN Delegate
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
     // Set input data
     std::vector<float> inputValues
     {
-        9.0f, 4.25f, 81.9f,
-        0.1f,  0.9f,  169.0f
+        1.f, 4.f, 16.f,
+        25.f, 64.f, 100.f
     };
-    // Calculate output data
-    std::vector<float> expectedOutputValues(inputValues.size());
-    for (unsigned int i = 0; i < inputValues.size(); ++i)
+    // Set output data
+    std::vector<float> expectedOutputValues
     {
-        expectedOutputValues[i] = std::sqrt(inputValues[i]);
-    }
+        1.f, 0.5f, 0.25f,
+        0.2f, 0.125f, 0.1f
+    };
 
-    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_SQRT, backends, inputValues, expectedOutputValues);
+    ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues);
 }
 
-TEST_CASE ("Sqrt_Float32_CpuAcc_Test")
+TEST_CASE ("Sqrt_Float32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
     // Set input data
     std::vector<float> inputValues
     {
@@ -234,6 +338,6 @@ TEST_CASE ("Sqrt_Float32_CpuAcc_Test")
     ElementwiseUnaryFP32Test(tflite::BuiltinOperator_SQRT, backends, inputValues, expectedOutputValues);
 }
 
-}
+} // TEST_SUITE("ElementwiseUnary_CpuRefTests")
 
 } // namespace armnnDelegate
\ No newline at end of file
diff --git a/delegate/src/test/ElementwiseUnaryTestHelper.hpp b/delegate/src/test/ElementwiseUnaryTestHelper.hpp
index b4a55cbe99..348c8abcef 100644
--- a/delegate/src/test/ElementwiseUnaryTestHelper.hpp
+++ b/delegate/src/test/ElementwiseUnaryTestHelper.hpp
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include "TestUtils.hpp"
+
 #include <armnn_delegate.hpp>
 
 #include <flatbuffers/flatbuffers.h>
@@ -79,7 +81,7 @@ void ElementwiseUnaryFP32Test(tflite::BuiltinOperator unaryOperatorCode,
                               std::vector<float>& expectedOutputValues)
 {
     using namespace tflite;
-    const std::vector<int32_t> inputShape  { { 3, 1, 2} };
+    std::vector<int32_t> inputShape  { { 3, 1, 2} };
     std::vector<char> modelBuffer = CreateElementwiseUnaryTfLiteModel(unaryOperatorCode,
                                                                       ::tflite::TensorType_FLOAT32,
                                                                       inputShape);
@@ -126,15 +128,7 @@ void ElementwiseUnaryFP32Test(tflite::BuiltinOperator unaryOperatorCode,
     CHECK(armnnDelegateInterpreter->Invoke() == kTfLiteOk);
 
     // Compare output data
-    auto tfLiteDelegateOutputId = tfLiteInterpreter->outputs()[0];
-    auto tfLiteDelageOutputData = tfLiteInterpreter->typed_tensor<float>(tfLiteDelegateOutputId);
-    auto armnnDelegateOutputId = armnnDelegateInterpreter->outputs()[0];
-    auto armnnDelegateOutputData = armnnDelegateInterpreter->typed_tensor<float>(armnnDelegateOutputId);
-    for (size_t i = 0; i < inputValues.size(); i++)
-    {
-        CHECK(expectedOutputValues[i] == armnnDelegateOutputData[i]);
-        CHECK(tfLiteDelageOutputData[i] == armnnDelegateOutputData[i]);
-    }
+    armnnDelegate::CompareOutputData(tfLiteInterpreter, armnnDelegateInterpreter, inputShape, expectedOutputValues);
 }
 
 } // anonymous namespace