IVGCVSW-5545 Fix delegate Comparison failures on CpuAcc/GpuAcc

 * Create backend test suite structure
 * Add special compare function for boolean values

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

1 files changed, 225 insertions, 135 deletions

diff --git a/delegate/src/test/ComparisonTest.cpp b/delegate/src/test/ComparisonTest.cpp
index 0826535c8f..95bfe21d27 100644
--- a/delegate/src/test/ComparisonTest.cpp
+++ b/delegate/src/test/ComparisonTest.cpp
@@ -497,258 +497,348 @@ void LessEqualInt32Test(std::vector<armnn::BackendId>& backends)
                             expectedOutputValues);
 }
 
-TEST_SUITE("ComparisonTest")
+TEST_SUITE("Comparison_CpuRefTests")
 {
 
-TEST_CASE ("EQUAL_FP32_GpuAcc_Test")
+TEST_CASE ("EQUAL_FP32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
     EqualFP32Test(backends);
 }
 
-TEST_CASE ("EQUAL_FP32_CpuAcc_Test")
+TEST_CASE ("EQUAL_Broadcast_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    EqualFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    EqualBroadcastTest(backends);
 }
 
-TEST_CASE ("EQUAL_Broadcast_GpuAcc_Test")
+TEST_CASE ("EQUAL_INT32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    EqualBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    EqualInt32Test(backends);
 }
 
-TEST_CASE ("EQUAL_Broadcast_CpuAcc_Test")
+TEST_CASE ("NOT_EQUAL_FP32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    EqualBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    NotEqualFP32Test(backends);
 }
 
-TEST_CASE ("EQUAL_INT32_GpuAcc_Test")
+TEST_CASE ("NOT_EQUAL_Broadcast_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    EqualInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    NotEqualBroadcastTest(backends);
 }
 
-TEST_CASE ("EQUAL_INT32_CpuAcc_Test")
+TEST_CASE ("NOT_EQUAL_INT32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    EqualInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    NotEqualInt32Test(backends);
 }
 
-TEST_CASE ("NOT_EQUAL_FP32_GpuAcc_Test")
+TEST_CASE ("GREATER_FP32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    NotEqualFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    GreaterFP32Test(backends);
 }
 
-TEST_CASE ("NOT_EQUAL_FP32_CpuAcc_Test")
+TEST_CASE ("GREATER_Broadcast_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    NotEqualFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    GreaterBroadcastTest(backends);
 }
 
-TEST_CASE ("NOT_EQUAL_Broadcast_GpuAcc_Test")
+TEST_CASE ("GREATER_INT32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    NotEqualBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    GreaterInt32Test(backends);
 }
 
-TEST_CASE ("NOT_EQUAL_Broadcast_CpuAcc_Test")
+TEST_CASE ("GREATER_EQUAL_FP32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    NotEqualBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    GreaterEqualFP32Test(backends);
 }
 
-TEST_CASE ("NOT_EQUAL_INT32_GpuAcc_Test")
+TEST_CASE ("GREATER_EQUAL_Broadcast_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    NotEqualInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    GreaterEqualBroadcastTest(backends);
 }
 
-TEST_CASE ("NOT_EQUAL_INT32_CpuAcc_Test")
+TEST_CASE ("GREATER_EQUAL_INT32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    NotEqualInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    GreaterEqualInt32Test(backends);
 }
 
-TEST_CASE ("GREATER_FP32_GpuAcc_Test")
+TEST_CASE ("LESS_FP32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    LessFP32Test(backends);
 }
 
-TEST_CASE ("GREATER_FP32_CpuAcc_Test")
+TEST_CASE ("LESS_Broadcast_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    LessBroadcastTest(backends);
 }
 
-TEST_CASE ("GREATER_Broadcast_GpuAcc_Test")
+TEST_CASE ("LESS_INT32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    LessInt32Test(backends);
 }
 
-TEST_CASE ("GREATER_Broadcast_CpuAcc_Test")
+TEST_CASE ("LESS_EQUAL_FP32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    LessEqualFP32Test(backends);
 }
 
-TEST_CASE ("GREATER_INT32_GpuAcc_Test")
+TEST_CASE ("LESS_EQUAL_Broadcast_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    LessEqualBroadcastTest(backends);
 }
 
-TEST_CASE ("GREATER_INT32_CpuAcc_Test")
+TEST_CASE ("LESS_EQUAL_INT32_CpuRef_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
+    LessEqualInt32Test(backends);
 }
-TEST_CASE ("GREATER_EQUAL_FP32_GpuAcc_Test")
+} // End TEST_SUITE("Comparison_CpuRefTests")
+
+
+
+TEST_SUITE("Comparison_GpuAccTests")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterEqualFP32Test(backends);
+
+TEST_CASE ("EQUAL_FP32_GpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    EqualFP32Test(backends);
 }
 
-TEST_CASE ("GREATER_EQUAL_FP32_CpuAcc_Test")
+TEST_CASE ("EQUAL_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterEqualFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    EqualBroadcastTest(backends);
 }
 
-TEST_CASE ("GREATER_EQUAL_Broadcast_GpuAcc_Test")
+TEST_CASE ("EQUAL_INT32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterEqualBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    EqualInt32Test(backends);
 }
 
-TEST_CASE ("GREATER_EQUAL_Broadcast_CpuAcc_Test")
+TEST_CASE ("NOT_EQUAL_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterEqualBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    NotEqualFP32Test(backends);
 }
 
-TEST_CASE ("GREATER_EQUAL_INT32_GpuAcc_Test")
+TEST_CASE ("NOT_EQUAL_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterEqualInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    NotEqualBroadcastTest(backends);
 }
 
-TEST_CASE ("GREATER_EQUAL_INT32_CpuAcc_Test")
+TEST_CASE ("NOT_EQUAL_INT32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    GreaterEqualInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    NotEqualInt32Test(backends);
 }
-TEST_CASE ("LESS_FP32_GpuAcc_Test")
+
+TEST_CASE ("GREATER_FP32_GpuAcc_Test")
 {
     std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
                                                armnn::Compute::CpuRef };
-    LessFP32Test(backends);
+    GreaterFP32Test(backends);
 }
 
-TEST_CASE ("LESS_FP32_CpuAcc_Test")
+TEST_CASE ("GREATER_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
                                                armnn::Compute::CpuRef };
-    LessFP32Test(backends);
+    GreaterBroadcastTest(backends);
 }
 
-TEST_CASE ("LESS_Broadcast_GpuAcc_Test")
+TEST_CASE ("GREATER_INT32_GpuAcc_Test")
 {
     std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
                                                armnn::Compute::CpuRef };
-    LessBroadcastTest(backends);
+    GreaterInt32Test(backends);
 }
 
-TEST_CASE ("LESS_Broadcast_CpuAcc_Test")
+TEST_CASE ("GREATER_EQUAL_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    LessBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    GreaterEqualFP32Test(backends);
 }
 
-TEST_CASE ("LESS_INT32_GpuAcc_Test")
+TEST_CASE ("GREATER_EQUAL_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    LessInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    GreaterEqualBroadcastTest(backends);
 }
 
-TEST_CASE ("LESS_INT32_CpuAcc_Test")
+TEST_CASE ("GREATER_EQUAL_INT32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    LessInt32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    GreaterEqualInt32Test(backends);
 }
-TEST_CASE ("LESS_EQUAL_FP32_GpuAcc_Test")
+
+TEST_CASE ("LESS_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    LessEqualFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    LessFP32Test(backends);
 }
 
-TEST_CASE ("LESS_EQUAL_FP32_CpuAcc_Test")
+TEST_CASE ("LESS_Broadcast_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
-    LessEqualFP32Test(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    LessBroadcastTest(backends);
 }
 
-TEST_CASE ("LESS_EQUAL_Broadcast_GpuAcc_Test")
+TEST_CASE ("LESS_INT32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
-    LessEqualBroadcastTest(backends);
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    LessInt32Test(backends);
 }
 
-TEST_CASE ("LESS_EQUAL_Broadcast_CpuAcc_Test")
+TEST_CASE ("LESS_EQUAL_FP32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
+    LessEqualFP32Test(backends);
+}
+
+TEST_CASE ("LESS_EQUAL_Broadcast_GpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
     LessEqualBroadcastTest(backends);
 }
 
 TEST_CASE ("LESS_EQUAL_INT32_GpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
     LessEqualInt32Test(backends);
 }
 
+} // End TEST_SUITE("Comparison_GpuAccTests")
+
+
+TEST_SUITE("Comparison_CpuAccTests")
+{
+
+TEST_CASE ("EQUAL_FP32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    EqualFP32Test(backends);
+}
+
+TEST_CASE ("EQUAL_Broadcast_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    EqualBroadcastTest(backends);
+}
+
+TEST_CASE ("EQUAL_INT32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    EqualInt32Test(backends);
+}
+
+TEST_CASE ("NOT_EQUAL_FP32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    NotEqualFP32Test(backends);
+}
+
+TEST_CASE ("NOT_EQUAL_Broadcast_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    NotEqualBroadcastTest(backends);
+}
+
+TEST_CASE ("NOT_EQUAL_INT32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    NotEqualInt32Test(backends);
+}
+
+TEST_CASE ("GREATER_FP32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    GreaterFP32Test(backends);
+}
+
+TEST_CASE ("GREATER_Broadcast_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    GreaterBroadcastTest(backends);
+}
+
+TEST_CASE ("GREATER_INT32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    GreaterInt32Test(backends);
+}
+
+TEST_CASE ("GREATER_EQUAL_FP32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    GreaterEqualFP32Test(backends);
+}
+
+TEST_CASE ("GREATER_EQUAL_Broadcast_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    GreaterEqualBroadcastTest(backends);
+}
+
+TEST_CASE ("GREATER_EQUAL_INT32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    GreaterEqualInt32Test(backends);
+}
+
+TEST_CASE ("LESS_FP32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    LessFP32Test(backends);
+}
+
+TEST_CASE ("LESS_Broadcast_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    LessBroadcastTest(backends);
+}
+
+TEST_CASE ("LESS_INT32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    LessInt32Test(backends);
+}
+
+TEST_CASE ("LESS_EQUAL_FP32_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    LessEqualFP32Test(backends);
+}
+
+TEST_CASE ("LESS_EQUAL_Broadcast_CpuAcc_Test")
+{
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
+    LessEqualBroadcastTest(backends);
+}
+
 TEST_CASE ("LESS_EQUAL_INT32_CpuAcc_Test")
 {
-    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
-                                               armnn::Compute::CpuRef };
+    std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
     LessEqualInt32Test(backends);
 }
 
-} // End TEST_SUITE("ComparisonTest")
+} // End TEST_SUITE("Comparison_CpuAccTests")
 
 } // namespace armnnDelegate
\ No newline at end of file