IVGCVSW-3996 Add deserialization test for ComparisonLayer

* Added DeserializeComparison.cpp that contains float32 and quantized
  deserialization test cases for all comparison operations
* Removed DeserializeEqual.cpp and DeserializeGreater.cpp, as they
  have become redundant

Signed-off-by: Aron Virginas-Tar <Aron.Virginas-Tar@arm.com>
Change-Id: I9577168721e1bc6bcc5bb2b35edf82390a816597

4 files changed, 254 insertions, 332 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 126a0ce1ff..fac3f16dc3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -764,15 +764,14 @@ if(BUILD_UNIT_TESTS)
             src/armnnDeserializer/test/DeserializeAdd.cpp
             src/armnnDeserializer/test/DeserializeBatchToSpaceNd.cpp
             src/armnnDeserializer/test/DeserializeBatchNormalization.cpp
+            src/armnnDeserializer/test/DeserializeComparison.cpp
             src/armnnDeserializer/test/DeserializeConstant.cpp
             src/armnnDeserializer/test/DeserializeConvolution2d.cpp
             src/armnnDeserializer/test/DeserializeDepthToSpace.cpp
             src/armnnDeserializer/test/DeserializeDivision.cpp
-            src/armnnDeserializer/test/DeserializeEqual.cpp
             src/armnnDeserializer/test/DeserializeFloor.cpp
             src/armnnDeserializer/test/DeserializeFullyConnected.cpp
             src/armnnDeserializer/test/DeserializeGather.cpp
-            src/armnnDeserializer/test/DeserializeGreater.cpp
             src/armnnDeserializer/test/DeserializeInstanceNormalization.cpp
             src/armnnDeserializer/test/DeserializeL2Normalization.cpp
             src/armnnDeserializer/test/DeserializeLogSoftmax.cpp
diff --git a/src/armnnDeserializer/test/DeserializeComparison.cpp b/src/armnnDeserializer/test/DeserializeComparison.cpp
new file mode 100644
index 0000000000..9a2fabf5bd
--- /dev/null
+++ b/src/armnnDeserializer/test/DeserializeComparison.cpp
@@ -0,0 +1,253 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ParserFlatbuffersSerializeFixture.hpp"
+#include "../Deserializer.hpp"
+
+#include <ResolveType.hpp>
+
+#include <backendsCommon/test/QuantizeHelper.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+
+BOOST_AUTO_TEST_SUITE(Deserializer)
+
+#define DECLARE_SIMPLE_COMPARISON_FIXTURE(operation, dataType) \
+struct Simple##operation##dataType##Fixture : public SimpleComparisonFixture \
+{ \
+    Simple##operation##dataType##Fixture() \
+        : SimpleComparisonFixture(#dataType, #operation) {} \
+};
+
+#define DECLARE_SIMPLE_COMPARISON_TEST_CASE(operation, dataType) \
+DECLARE_SIMPLE_COMPARISON_FIXTURE(operation, dataType) \
+BOOST_FIXTURE_TEST_CASE(operation##dataType, Simple##operation##dataType##Fixture) \
+{ \
+    using T = armnn::ResolveType<armnn::DataType::dataType>; \
+    constexpr float   qScale  = 1.f; \
+    constexpr int32_t qOffset = 0; \
+    RunTest<4, armnn::DataType::dataType, armnn::DataType::Boolean>( \
+        0, \
+        {{ "InputLayer0", QuantizedVector<T>(qScale, qOffset, s_TestData.m_InputData0)  }, \
+         { "InputLayer1", QuantizedVector<T>(qScale, qOffset, s_TestData.m_InputData1)  }}, \
+        {{ "OutputLayer", s_TestData.m_Output##operation }}); \
+}
+
+struct ComparisonFixture : public ParserFlatbuffersSerializeFixture
+{
+    explicit ComparisonFixture(const std::string& inputShape0,
+                               const std::string& inputShape1,
+                               const std::string& outputShape,
+                               const std::string& inputDataType,
+                               const std::string& comparisonOperation)
+    {
+        m_JsonString = R"(
+            {
+                inputIds: [0, 1],
+                outputIds: [3],
+                layers: [
+                    {
+                        layer_type: "InputLayer",
+                        layer: {
+                            base: {
+                                layerBindingId: 0,
+                                base: {
+                                    index: 0,
+                                    layerName: "InputLayer0",
+                                    layerType: "Input",
+                                    inputSlots: [{
+                                        index: 0,
+                                        connection: { sourceLayerIndex:0, outputSlotIndex:0 },
+                                    }],
+                                    outputSlots: [{
+                                        index: 0,
+                                        tensorInfo: {
+                                            dimensions: )" + inputShape0 + R"(,
+                                            dataType: )" + inputDataType + R"(
+                                        },
+                                    }],
+                                },
+                            }
+                        },
+                    },
+                    {
+                        layer_type: "InputLayer",
+                        layer: {
+                            base: {
+                                layerBindingId: 1,
+                                base: {
+                                      index:1,
+                                      layerName: "InputLayer1",
+                                      layerType: "Input",
+                                      inputSlots: [{
+                                          index: 0,
+                                          connection: { sourceLayerIndex:0, outputSlotIndex:0 },
+                                      }],
+                                      outputSlots: [{
+                                          index: 0,
+                                          tensorInfo: {
+                                              dimensions: )" + inputShape1 + R"(,
+                                              dataType: )" + inputDataType + R"(
+                                          },
+                                      }],
+                                },
+                            }
+                        },
+                    },
+                    {
+                        layer_type: "ComparisonLayer",
+                        layer: {
+                            base: {
+                                 index:2,
+                                 layerName: "ComparisonLayer",
+                                 layerType: "Comparison",
+                                 inputSlots: [{
+                                     index: 0,
+                                     connection: { sourceLayerIndex:0, outputSlotIndex:0 },
+                                 },
+                                 {
+                                     index: 1,
+                                     connection: { sourceLayerIndex:1, outputSlotIndex:0 },
+                                 }],
+                                 outputSlots: [{
+                                     index: 0,
+                                     tensorInfo: {
+                                         dimensions: )" + outputShape + R"(,
+                                         dataType: Boolean
+                                     },
+                                 }],
+                            },
+                            descriptor: {
+                                operation: )" + comparisonOperation + R"(
+                            }
+                        },
+                    },
+                    {
+                        layer_type: "OutputLayer",
+                        layer: {
+                            base:{
+                                layerBindingId: 0,
+                                base: {
+                                    index: 3,
+                                    layerName: "OutputLayer",
+                                    layerType: "Output",
+                                    inputSlots: [{
+                                        index: 0,
+                                        connection: { sourceLayerIndex:2, outputSlotIndex:0 },
+                                    }],
+                                    outputSlots: [{
+                                        index: 0,
+                                        tensorInfo: {
+                                            dimensions: )" + outputShape + R"(,
+                                            dataType: Boolean
+                                        },
+                                    }],
+                                }
+                            }
+                        },
+                    }
+                ]
+            }
+        )";
+        Setup();
+    }
+};
+
+struct SimpleComparisonTestData
+{
+    SimpleComparisonTestData()
+    {
+        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
+        };
+    }
+
+    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;
+};
+
+struct SimpleComparisonFixture : public ComparisonFixture
+{
+    SimpleComparisonFixture(const std::string& inputDataType,
+                            const std::string& comparisonOperation)
+        : ComparisonFixture("[ 2, 2, 2, 2 ]", // inputShape0
+                            "[ 2, 2, 2, 2 ]", // inputShape1
+                            "[ 2, 2, 2, 2 ]", // outputShape,
+                            inputDataType,
+                            comparisonOperation) {}
+
+    static SimpleComparisonTestData s_TestData;
+};
+
+SimpleComparisonTestData SimpleComparisonFixture::s_TestData;
+
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(Equal,          Float32)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(Greater,        Float32)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(GreaterOrEqual, Float32)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(Less,           Float32)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(LessOrEqual,    Float32)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(NotEqual,       Float32)
+
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(Equal,          QuantisedAsymm8)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(Greater,        QuantisedAsymm8)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(GreaterOrEqual, QuantisedAsymm8)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(Less,           QuantisedAsymm8)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(LessOrEqual,    QuantisedAsymm8)
+DECLARE_SIMPLE_COMPARISON_TEST_CASE(NotEqual,       QuantisedAsymm8)
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/armnnDeserializer/test/DeserializeEqual.cpp b/src/armnnDeserializer/test/DeserializeEqual.cpp
deleted file mode 100644
index 7d8213cd95..0000000000
--- a/src/armnnDeserializer/test/DeserializeEqual.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include <boost/test/unit_test.hpp>
-#include "ParserFlatbuffersSerializeFixture.hpp"
-#include "../Deserializer.hpp"
-
-#include <string>
-#include <iostream>
-
-BOOST_AUTO_TEST_SUITE(Deserializer)
-
-struct EqualFixture : public ParserFlatbuffersSerializeFixture
-{
-    explicit EqualFixture(const std::string & inputShape1,
-                          const std::string & inputShape2,
-                          const std::string & outputShape,
-                          const std::string & dataType)
-    {
-        m_JsonString = R"(
-            {
-                inputIds: [0, 1],
-                outputIds: [3],
-                layers: [
-                    {
-                        layer_type: "InputLayer",
-                        layer: {
-                            base: {
-                                layerBindingId: 0,
-                                base: {
-                                    index: 0,
-                                    layerName: "InputLayer1",
-                                    layerType: "Input",
-                                    inputSlots: [{
-                                        index: 0,
-                                        connection: {sourceLayerIndex:0, outputSlotIndex:0 },
-                                    }],
-                                    outputSlots: [{
-                                        index: 0,
-                                        tensorInfo: {
-                                            dimensions: )" + inputShape1 + R"(,
-                                            dataType: )" + dataType + R"(
-                                        },
-                                    }],
-                                },
-                            }
-                        },
-                    },
-                    {
-                        layer_type: "InputLayer",
-                        layer: {
-                            base: {
-                                layerBindingId: 1,
-                                base: {
-                                      index:1,
-                                      layerName: "InputLayer2",
-                                      layerType: "Input",
-                                      inputSlots: [{
-                                          index: 0,
-                                          connection: {sourceLayerIndex:0, outputSlotIndex:0 },
-                                      }],
-                                      outputSlots: [{
-                                          index: 0,
-                                          tensorInfo: {
-                                              dimensions: )" + inputShape2 + R"(,
-                                              dataType: )" + dataType + R"(
-                                          },
-                                      }],
-                                },
-                            }
-                        },
-                    },
-                    {
-                        layer_type: "EqualLayer",
-                        layer: {
-                            base: {
-                                 index:2,
-                                 layerName: "EqualLayer",
-                                 layerType: "Equal",
-                                 inputSlots: [{
-                                     index: 0,
-                                     connection: {sourceLayerIndex:0, outputSlotIndex:0 },
-                                 },
-                                 {
-                                     index: 1,
-                                     connection: {sourceLayerIndex:1, outputSlotIndex:0 },
-                                 }],
-                                 outputSlots: [{
-                                     index: 0,
-                                     tensorInfo: {
-                                         dimensions: )" + outputShape + R"(,
-                                         dataType: Boolean
-                                     },
-                                 }],
-                            }
-                        },
-                    },
-                    {
-                        layer_type: "OutputLayer",
-                        layer: {
-                            base:{
-                                layerBindingId: 0,
-                                base: {
-                                    index: 3,
-                                    layerName: "OutputLayer",
-                                    layerType: "Output",
-                                    inputSlots: [{
-                                        index: 0,
-                                        connection: {sourceLayerIndex:2, outputSlotIndex:0 },
-                                    }],
-                                    outputSlots: [{
-                                        index: 0,
-                                        tensorInfo: {
-                                            dimensions: )" + outputShape + R"(,
-                                            dataType: Boolean
-                                        },
-                                    }],
-                                }
-                            }
-                        },
-                    }
-                ]
-            }
-        )";
-        Setup();
-    }
-};
-
-struct SimpleEqualFixture : EqualFixture
-{
-    SimpleEqualFixture() : EqualFixture("[ 2, 2, 2, 1 ]",
-                                        "[ 2, 2, 2, 1 ]",
-                                        "[ 2, 2, 2, 1 ]",
-                                        "QuantisedAsymm8") {}
-};
-
-BOOST_FIXTURE_TEST_CASE(EqualQuantisedAsymm8, SimpleEqualFixture)
-{
-  RunTest<4, armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(
-      0,
-      {{"InputLayer1", { 0, 1, 2, 3, 4, 5, 6, 7 }},
-       {"InputLayer2", { 0, 0, 0, 3, 0, 0, 6, 7 }}},
-      {{"OutputLayer", { 1, 0, 0, 1, 0, 0, 1, 1 }}});
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/armnnDeserializer/test/DeserializeGreater.cpp b/src/armnnDeserializer/test/DeserializeGreater.cpp
deleted file mode 100644
index d1ff250d3d..0000000000
--- a/src/armnnDeserializer/test/DeserializeGreater.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include <boost/test/unit_test.hpp>
-#include "ParserFlatbuffersSerializeFixture.hpp"
-#include "../Deserializer.hpp"
-
-#include <string>
-#include <iostream>
-
-BOOST_AUTO_TEST_SUITE(Deserializer)
-
-struct GreaterFixture : public ParserFlatbuffersSerializeFixture
-{
-    explicit GreaterFixture(const std::string & inputShape1,
-                            const std::string & inputShape2,
-                            const std::string & outputShape,
-                            const std::string & inputDataType,
-                            const std::string & outputDataType)
-    {
-        m_JsonString = R"(
-        {
-                inputIds: [0, 1],
-                outputIds: [3],
-                layers: [
-                {
-                    layer_type: "InputLayer",
-                    layer: {
-                          base: {
-                                layerBindingId: 0,
-                                base: {
-                                    index: 0,
-                                    layerName: "InputLayer1",
-                                    layerType: "Input",
-                                    inputSlots: [{
-                                        index: 0,
-                                        connection: {sourceLayerIndex:0, outputSlotIndex:0 },
-                                    }],
-                                    outputSlots: [ {
-                                        index: 0,
-                                        tensorInfo: {
-                                            dimensions: )" + inputShape1 + R"(,
-                                            dataType: )" + inputDataType + R"(
-                                        },
-                                    }],
-                                 },}},
-                },
-                {
-                layer_type: "InputLayer",
-                layer: {
-                       base: {
-                            layerBindingId: 1,
-                            base: {
-                                  index:1,
-                                  layerName: "InputLayer2",
-                                  layerType: "Input",
-                                  inputSlots: [{
-                                      index: 0,
-                                      connection: {sourceLayerIndex:0, outputSlotIndex:0 },
-                                  }],
-                                  outputSlots: [ {
-                                      index: 0,
-                                      tensorInfo: {
-                                          dimensions: )" + inputShape2 + R"(,
-                                          dataType: )" + inputDataType + R"(
-                                      },
-                                  }],
-                                },}},
-                },
-                {
-                layer_type: "GreaterLayer",
-                layer : {
-                        base: {
-                             index:2,
-                             layerName: "GreaterLayer",
-                             layerType: "Greater",
-                             inputSlots: [
-                                            {
-                                             index: 0,
-                                             connection: {sourceLayerIndex:0, outputSlotIndex:0 },
-                                            },
-                                            {
-                                             index: 1,
-                                             connection: {sourceLayerIndex:1, outputSlotIndex:0 },
-                                            }
-                             ],
-                             outputSlots: [ {
-                                 index: 0,
-                                 tensorInfo: {
-                                     dimensions: )" + outputShape + R"(,
-                                     dataType: Boolean
-                                 },
-                             }],
-                            }},
-                },
-                {
-                layer_type: "OutputLayer",
-                layer: {
-                        base:{
-                              layerBindingId: 0,
-                              base: {
-                                    index: 3,
-                                    layerName: "OutputLayer",
-                                    layerType: "Output",
-                                    inputSlots: [{
-                                        index: 0,
-                                        connection: {sourceLayerIndex:2, outputSlotIndex:0 },
-                                    }],
-                                    outputSlots: [ {
-                                        index: 0,
-                                        tensorInfo: {
-                                            dimensions: )" + outputShape + R"(,
-                                            dataType: )" + outputDataType + R"(
-                                        },
-                                }],
-                            }}},
-                }]
-         }
-        )";
-        Setup();
-    }
-};
-
-
-struct SimpleGreaterFixtureQuantisedAsymm8 : GreaterFixture
-{
-    SimpleGreaterFixtureQuantisedAsymm8() : GreaterFixture("[ 2, 2 ]",        // input1Shape
-                                                           "[ 2, 2 ]",        // input2Shape
-                                                           "[ 2, 2 ]",        // outputShape
-                                                           "QuantisedAsymm8", // inputDataType
-                                                           "Float32") {}      // outputDataType
-};
-
-struct SimpleGreaterFixtureFloat32 : GreaterFixture
-{
-    SimpleGreaterFixtureFloat32() : GreaterFixture("[ 2, 2, 1, 1 ]", // input1Shape
-                                                   "[ 2, 2, 1, 1 ]", // input2Shape
-                                                   "[ 2, 2, 1, 1 ]", // outputShape
-                                                   "Float32",        // inputDataType
-                                                   "Float32") {}     // outputDataType
-};
-
-struct SimpleGreaterFixtureBroadcast : GreaterFixture
-{
-    SimpleGreaterFixtureBroadcast() : GreaterFixture("[ 1, 2, 2, 2 ]", // input1Shape
-                                                     "[ 1, 1, 1, 1 ]", // input2Shape
-                                                     "[ 1, 2, 2, 2 ]", // outputShape
-                                                     "Float32",        // inputDataType
-                                                     "Float32") {}     // outputDataType
-};
-
-
-BOOST_FIXTURE_TEST_CASE(GreaterQuantisedAsymm8, SimpleGreaterFixtureQuantisedAsymm8)
-{
-    RunTest<2, armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(
-        0,
-        {{"InputLayer1", { 1, 5, 8, 7 }},
-        { "InputLayer2", { 4, 0, 6, 7 }}},
-        {{"OutputLayer", { 0, 1, 1, 0 }}});
-}
-
-BOOST_FIXTURE_TEST_CASE(GreaterFloat32, SimpleGreaterFixtureFloat32)
-{
-    RunTest<4, armnn::DataType::Float32, armnn::DataType::Boolean>(
-        0,
-        {{"InputLayer1", { 1.0f, 2.0f, 3.0f, 4.0f }},
-        { "InputLayer2", { 1.0f, 5.0f, 2.0f, 2.0f }}},
-        {{"OutputLayer", { 0, 0, 1, 1 }}});
-}
-
-BOOST_FIXTURE_TEST_CASE(GreaterBroadcast, SimpleGreaterFixtureBroadcast)
-{
-    RunTest<4, armnn::DataType::Float32, armnn::DataType::Boolean>(
-        0,
-        {{"InputLayer1", { 1, 2, 3, 4, 5, 6, 7, 8 }},
-         {"InputLayer2", { 1 }}},
-        {{"OutputLayer", { 0, 1, 1, 1, 1, 1, 1, 1 }}});
-}
-
-BOOST_AUTO_TEST_SUITE_END()