IVGCVSW-3992 Add serialization support for ComparisonLayer

* Added serialization support and serialization-deserialization test
  for Comparison
* Added backward compatibility tests for Equal and Greater, to make
  sure they are serialized and deserialized as Comparison
* Refactored serialization tests and reduced code duplication by
  taking advantage of operator==() recently added for Descriptors

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

9 files changed, 412 insertions, 928 deletions

diff --git a/src/armnnDeserializer/Deserializer.cpp b/src/armnnDeserializer/Deserializer.cpp
index 0b18ccd051..6779f1eb06 100644
--- a/src/armnnDeserializer/Deserializer.cpp
+++ b/src/armnnDeserializer/Deserializer.cpp
@@ -191,6 +191,7 @@ m_ParserFunctions(Layer_MAX+1, &Deserializer::ParseUnsupportedLayer)
     m_ParserFunctions[Layer_ArgMinMaxLayer]              = &Deserializer::ParseArgMinMax;
     m_ParserFunctions[Layer_BatchToSpaceNdLayer]         = &Deserializer::ParseBatchToSpaceNd;
     m_ParserFunctions[Layer_BatchNormalizationLayer]     = &Deserializer::ParseBatchNormalization;
+    m_ParserFunctions[Layer_ComparisonLayer]             = &Deserializer::ParseComparison;
     m_ParserFunctions[Layer_ConcatLayer]                 = &Deserializer::ParseConcat;
     m_ParserFunctions[Layer_ConstantLayer]               = &Deserializer::ParseConstant;
     m_ParserFunctions[Layer_Convolution2dLayer]          = &Deserializer::ParseConvolution2d;
@@ -255,6 +256,8 @@ Deserializer::LayerBaseRawPtr Deserializer::GetBaseLayer(const GraphPtr& graphPt
             return graphPtr->layers()->Get(layerIndex)->layer_as_BatchToSpaceNdLayer()->base();
         case Layer::Layer_BatchNormalizationLayer:
             return graphPtr->layers()->Get(layerIndex)->layer_as_BatchNormalizationLayer()->base();
+        case Layer::Layer_ComparisonLayer:
+            return graphPtr->layers()->Get(layerIndex)->layer_as_ComparisonLayer()->base();
         case Layer::Layer_ConcatLayer:
             return graphPtr->layers()->Get(layerIndex)->layer_as_ConcatLayer()->base();
         case Layer::Layer_ConstantLayer:
@@ -428,6 +431,26 @@ armnn::ArgMinMaxFunction ToArgMinMaxFunction(armnnSerializer::ArgMinMaxFunction
     }
 }
 
+armnn::ComparisonOperation ToComparisonOperation(armnnSerializer::ComparisonOperation operation)
+{
+    switch (operation)
+    {
+        case armnnSerializer::ComparisonOperation::ComparisonOperation_Equal:
+            return armnn::ComparisonOperation::Equal;
+        case armnnSerializer::ComparisonOperation::ComparisonOperation_Greater:
+            return armnn::ComparisonOperation::Greater;
+        case armnnSerializer::ComparisonOperation::ComparisonOperation_GreaterOrEqual:
+            return armnn::ComparisonOperation::GreaterOrEqual;
+        case armnnSerializer::ComparisonOperation::ComparisonOperation_Less:
+            return armnn::ComparisonOperation::Less;
+        case armnnSerializer::ComparisonOperation::ComparisonOperation_LessOrEqual:
+            return armnn::ComparisonOperation::LessOrEqual;
+        case armnnSerializer::ComparisonOperation::ComparisonOperation_NotEqual:
+        default:
+            return armnn::ComparisonOperation::NotEqual;
+    }
+}
+
 armnn::ResizeMethod ToResizeMethod(armnnSerializer::ResizeMethod method)
 {
     switch (method)
@@ -1436,6 +1459,33 @@ const armnnSerializer::OriginsDescriptor* GetOriginsDescriptor(const armnnSerial
     }
 }
 
+void Deserializer::ParseComparison(GraphPtr graph, unsigned int layerIndex)
+{
+    CHECK_LAYERS(graph, 0, layerIndex);
+    CHECK_LOCATION();
+
+    auto inputs = GetInputs(graph, layerIndex);
+    CHECK_VALID_SIZE(inputs.size(), 2);
+
+    auto outputs = GetOutputs(graph, layerIndex);
+    CHECK_VALID_SIZE(outputs.size(), 1);
+
+    auto fbLayer      = graph->layers()->Get(layerIndex)->layer_as_ComparisonLayer();
+    auto fbDescriptor = fbLayer->descriptor();
+
+    armnn::ComparisonDescriptor descriptor;
+    descriptor.m_Operation = ToComparisonOperation(fbDescriptor->operation());
+
+    const std::string& layerName = GetLayerName(graph, layerIndex);
+    IConnectableLayer* layer     = m_Network->AddComparisonLayer(descriptor, layerName.c_str());
+
+    armnn::TensorInfo outputTensorInfo = ToTensorInfo(outputs[0]);
+    layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
+
+    RegisterInputSlots(graph, layerIndex, layer);
+    RegisterOutputSlots(graph, layerIndex, layer);
+}
+
 void Deserializer::ParseConcat(GraphPtr graph, unsigned int layerIndex)
 {
     CHECK_LAYERS(graph, 0, layerIndex);
diff --git a/src/armnnDeserializer/Deserializer.hpp b/src/armnnDeserializer/Deserializer.hpp
index dda588d5e3..b951483926 100644
--- a/src/armnnDeserializer/Deserializer.hpp
+++ b/src/armnnDeserializer/Deserializer.hpp
@@ -83,6 +83,7 @@ private:
     void ParseArgMinMax(GraphPtr graph, unsigned int layerIndex);
     void ParseBatchToSpaceNd(GraphPtr graph, unsigned int layerIndex);
     void ParseBatchNormalization(GraphPtr graph, unsigned int layerIndex);
+    void ParseComparison(GraphPtr graph, unsigned int layerIndex);
     void ParseConcat(GraphPtr graph, unsigned int layerIndex);
     void ParseConstant(GraphPtr graph, unsigned int layerIndex);
     void ParseConvolution2d(GraphPtr graph, unsigned int layerIndex);
@@ -166,4 +167,4 @@ private:
     std::unordered_map<unsigned int, Connections> m_GraphConnections;
 };
 
-} //namespace armnnDeserializer
+} // namespace armnnDeserializer
diff --git a/src/armnnDeserializer/DeserializerSupport.md b/src/armnnDeserializer/DeserializerSupport.md
index 3b35e5c9f4..fce7064337 100644
--- a/src/armnnDeserializer/DeserializerSupport.md
+++ b/src/armnnDeserializer/DeserializerSupport.md
@@ -13,6 +13,7 @@ The Arm NN SDK Deserialize parser currently supports the following layers:
 * BatchToSpaceNd
 * BatchNormalization
 * Concat
+* Comparison
 * Constant
 * Convolution2d
 * DepthToSpace
@@ -20,11 +21,9 @@ The Arm NN SDK Deserialize parser currently supports the following layers:
 * Dequantize
 * DetectionPostProcess
 * Division
-* Equal
 * Floor
 * FullyConnected
 * Gather
-* Greater
 * Input
 * InstanceNormalization
 * L2Normalization
@@ -44,7 +43,6 @@ The Arm NN SDK Deserialize parser currently supports the following layers:
 * Quantize
 * QuantizedLstm
 * Reshape
-* ResizeBilinear
 * Rsqrt
 * Slice
 * Softmax
@@ -59,3 +57,12 @@ The Arm NN SDK Deserialize parser currently supports the following layers:
 * Resize
 
 More machine learning layers will be supported in future releases.
+
+## Deprecated layers
+
+Some layers have been deprecated and replaced by others layers. In order to maintain backward compatibility, serializations of these deprecated layers will deserialize to the layers that have replaced them, as follows:
+
+* Equal will deserialize as Comparison
+* Merger will deserialize as Concat
+* Greater will deserialize as Comparison
+* ResizeBilinear will deserialize as Resize
diff --git a/src/armnnSerializer/ArmnnSchema.fbs b/src/armnnSerializer/ArmnnSchema.fbs
index 187a091ba0..0756784cd3 100644
--- a/src/armnnSerializer/ArmnnSchema.fbs
+++ b/src/armnnSerializer/ArmnnSchema.fbs
@@ -143,7 +143,8 @@ enum LayerType : uint {
     Slice = 48,
     DepthToSpace = 49,
     InstanceNormalization = 50,
-    LogSoftmax = 51
+    LogSoftmax = 51,
+    Comparison = 52
 }
 
 // Base layer table to be used as part of other layers
@@ -191,6 +192,24 @@ table ArgMinMaxDescriptor{
     axis:int;
 }
 
+enum ComparisonOperation : byte {
+    Equal = 0,
+    Greater = 1,
+    GreaterOrEqual = 2,
+    Less = 3,
+    LessOrEqual = 4,
+    NotEqual = 5
+}
+
+table ComparisonDescriptor {
+    operation:ComparisonOperation;
+}
+
+table ComparisonLayer {
+    base:LayerBase;
+    descriptor:ComparisonDescriptor;
+}
+
 table ConstantLayer {
     base:LayerBase;
     input:ConstTensor;
@@ -230,6 +249,7 @@ table DivisionLayer {
     base:LayerBase;
 }
 
+/// @deprecated Use ComparisonLayer instead
 table EqualLayer {
     base:LayerBase;
 }
@@ -254,6 +274,7 @@ table GatherLayer {
     base:LayerBase;
 }
 
+/// @deprecated Use ComparisonLayer instead
 table GreaterLayer {
     base:LayerBase;
 }
@@ -496,6 +517,7 @@ table BatchNormalizationDescriptor {
     dataLayout:DataLayout;
 }
 
+/// @deprecated Use ResizeLayer instead
 table ResizeBilinearLayer {
     base:LayerBase;
     descriptor:ResizeBilinearDescriptor;
@@ -539,6 +561,7 @@ table ConcatLayer {
     descriptor:OriginsDescriptor;
 }
 
+/// @deprecated Use ConcatLayer instead
 table MergerLayer {
     base:LayerBase;
     descriptor:OriginsDescriptor;
@@ -760,7 +783,8 @@ union Layer {
     SliceLayer,
     DepthToSpaceLayer,
     InstanceNormalizationLayer,
-    LogSoftmaxLayer
+    LogSoftmaxLayer,
+    ComparisonLayer
 }
 
 table AnyLayer {
diff --git a/src/armnnSerializer/Serializer.cpp b/src/armnnSerializer/Serializer.cpp
index 5c9855f87e..6122351812 100644
--- a/src/armnnSerializer/Serializer.cpp
+++ b/src/armnnSerializer/Serializer.cpp
@@ -244,7 +244,13 @@ void SerializerVisitor::VisitComparisonLayer(const armnn::IConnectableLayer* lay
                                              const armnn::ComparisonDescriptor& descriptor,
                                              const char* name)
 {
-    throw armnn::UnimplementedException("SerializerVisitor::VisitComparisonLayer() is not implemented");
+    auto fbBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_Comparison);
+    auto fbDescriptor = serializer::CreateComparisonDescriptor(
+        m_flatBufferBuilder,
+        GetFlatBufferComparisonOperation(descriptor.m_Operation));
+
+    auto fbLayer = serializer::CreateComparisonLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
+    CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_ComparisonLayer);
 }
 
 // Build FlatBuffer for Constant Layer
diff --git a/src/armnnSerializer/SerializerSupport.md b/src/armnnSerializer/SerializerSupport.md
index 2def918f21..4b12f9ca23 100644
--- a/src/armnnSerializer/SerializerSupport.md
+++ b/src/armnnSerializer/SerializerSupport.md
@@ -20,11 +20,9 @@ The Arm NN SDK Serializer currently supports the following layers:
 * Dequantize
 * DetectionPostProcess
 * Division
-* Equal
 * Floor
 * FullyConnected
 * Gather
-* Greater
 * Input
 * InstanceNormalization
 * L2Normalization
@@ -45,7 +43,6 @@ The Arm NN SDK Serializer currently supports the following layers:
 * QuantizedLstm
 * Reshape
 * Resize
-* ResizeBilinear
 * Rsqrt
 * Slice
 * Softmax
@@ -60,6 +57,11 @@ The Arm NN SDK Serializer currently supports the following layers:
 
 More machine learning layers will be supported in future releases.
 
-Note: Merger layer has been renamed Concat. Serializations of the old
-      format with Merger layers will deserialize to Concat layers to
-      maintain backward compatibility.
+## Deprecated layers
+
+Some layers have been deprecated and replaced by others layers. In order to maintain backward compatibility, serializations of these deprecated layers will deserialize to the layers that have replaced them, as follows:
+
+* Equal will deserialize as Comparison
+* Merger will deserialize as Concat
+* Greater will deserialize as Comparison
+* ResizeBilinear will deserialize as Resize
diff --git a/src/armnnSerializer/SerializerUtils.cpp b/src/armnnSerializer/SerializerUtils.cpp
index 9790d6e23b..719f8a92dd 100644
--- a/src/armnnSerializer/SerializerUtils.cpp
+++ b/src/armnnSerializer/SerializerUtils.cpp
@@ -8,7 +8,25 @@
 namespace armnnSerializer
 {
 
-using namespace armnn;
+armnnSerializer::ComparisonOperation GetFlatBufferComparisonOperation(armnn::ComparisonOperation comparisonOperation)
+{
+    switch (comparisonOperation)
+    {
+        case armnn::ComparisonOperation::Equal:
+            return armnnSerializer::ComparisonOperation::ComparisonOperation_Equal;
+        case armnn::ComparisonOperation::Greater:
+            return armnnSerializer::ComparisonOperation::ComparisonOperation_Greater;
+        case armnn::ComparisonOperation::GreaterOrEqual:
+            return armnnSerializer::ComparisonOperation::ComparisonOperation_GreaterOrEqual;
+        case armnn::ComparisonOperation::Less:
+            return armnnSerializer::ComparisonOperation::ComparisonOperation_Less;
+        case armnn::ComparisonOperation::LessOrEqual:
+            return armnnSerializer::ComparisonOperation::ComparisonOperation_LessOrEqual;
+        case armnn::ComparisonOperation::NotEqual:
+        default:
+            return armnnSerializer::ComparisonOperation::ComparisonOperation_NotEqual;
+    }
+}
 
 armnnSerializer::ConstTensorData GetFlatBufferConstTensorData(armnn::DataType dataType)
 {
@@ -137,4 +155,4 @@ armnnSerializer::ResizeMethod GetFlatBufferResizeMethod(armnn::ResizeMethod meth
     }
 }
 
-} // namespace armnnSerializer
\ No newline at end of file
+} // namespace armnnSerializer
diff --git a/src/armnnSerializer/SerializerUtils.hpp b/src/armnnSerializer/SerializerUtils.hpp
index 578689b2dd..16b83e3ed7 100644
--- a/src/armnnSerializer/SerializerUtils.hpp
+++ b/src/armnnSerializer/SerializerUtils.hpp
@@ -11,6 +11,8 @@
 namespace armnnSerializer
 {
 
+armnnSerializer::ComparisonOperation GetFlatBufferComparisonOperation(armnn::ComparisonOperation comparisonOperation);
+
 armnnSerializer::ConstTensorData GetFlatBufferConstTensorData(armnn::DataType dataType);
 
 armnnSerializer::DataType GetFlatBufferDataType(armnn::DataType dataType);
diff --git a/src/armnnSerializer/test/SerializerTests.cpp b/src/armnnSerializer/test/SerializerTests.cpp
index 58f56f484f..ebca61e57c 100644
--- a/src/armnnSerializer/test/SerializerTests.cpp
+++ b/src/armnnSerializer/test/SerializerTests.cpp
@@ -19,6 +19,41 @@ using armnnDeserializer::IDeserializer;
 namespace
 {
 
+#define DECLARE_LAYER_VERIFIER_CLASS(name) \
+class name##LayerVerifier : public LayerVerifierBase \
+{ \
+public: \
+    name##LayerVerifier(const std::string& layerName, \
+                        const std::vector<armnn::TensorInfo>& inputInfos, \
+                        const std::vector<armnn::TensorInfo>& outputInfos) \
+        : LayerVerifierBase(layerName, inputInfos, outputInfos) {} \
+\
+    void Visit##name##Layer(const armnn::IConnectableLayer* layer, const char* name) override \
+    { \
+        VerifyNameAndConnections(layer, name); \
+    } \
+};
+
+#define DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(name) \
+class name##LayerVerifier : public LayerVerifierBaseWithDescriptor<armnn::name##Descriptor> \
+{ \
+public: \
+    name##LayerVerifier(const std::string& layerName, \
+                        const std::vector<armnn::TensorInfo>& inputInfos, \
+                        const std::vector<armnn::TensorInfo>& outputInfos, \
+                        const armnn::name##Descriptor& descriptor) \
+        : LayerVerifierBaseWithDescriptor<armnn::name##Descriptor>( \
+            layerName, inputInfos, outputInfos, descriptor) {} \
+\
+    void Visit##name##Layer(const armnn::IConnectableLayer* layer, \
+                            const armnn::name##Descriptor& descriptor, \
+                            const char* name) override \
+    { \
+        VerifyNameAndConnections(layer, name); \
+        VerifyDescriptor(descriptor); \
+    } \
+};
+
 struct DefaultLayerVerifierPolicy
 {
     static void Apply(const std::string s = "")
@@ -126,6 +161,27 @@ private:
     std::vector<armnn::TensorInfo> m_OutputTensorInfos;
 };
 
+template<typename Descriptor>
+class LayerVerifierBaseWithDescriptor : public LayerVerifierBase
+{
+public:
+    LayerVerifierBaseWithDescriptor(const std::string& layerName,
+                                    const std::vector<armnn::TensorInfo>& inputInfos,
+                                    const std::vector<armnn::TensorInfo>& outputInfos,
+                                    const Descriptor& descriptor)
+        : LayerVerifierBase(layerName, inputInfos, outputInfos)
+        , m_Descriptor(descriptor) {}
+
+protected:
+    void VerifyDescriptor(const Descriptor& descriptor)
+    {
+        BOOST_CHECK(descriptor == m_Descriptor);
+    }
+
+private:
+    Descriptor m_Descriptor;
+};
+
 template<typename T>
 void CompareConstTensorData(const void* data1, const void* data2, unsigned int numElements)
 {
@@ -212,19 +268,7 @@ BOOST_AUTO_TEST_SUITE(SerializerTests)
 
 BOOST_AUTO_TEST_CASE(SerializeAbs)
 {
-    class AbsLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        AbsLayerVerifier(const std::string& layerName,
-                              const std::vector<armnn::TensorInfo>& inputInfos,
-                              const std::vector<armnn::TensorInfo>& outputInfos)
-                : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitAbsLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Abs)
 
     const std::string layerName("abs");
     const armnn::TensorInfo tensorInfo({1, 2, 3}, armnn::DataType::Float32);
@@ -250,19 +294,7 @@ BOOST_AUTO_TEST_CASE(SerializeAbs)
 
 BOOST_AUTO_TEST_CASE(SerializeAddition)
 {
-    class AdditionLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        AdditionLayerVerifier(const std::string& layerName,
-                              const std::vector<armnn::TensorInfo>& inputInfos,
-                              const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitAdditionLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Addition)
 
     const std::string layerName("addition");
     const armnn::TensorInfo tensorInfo({1, 2, 3}, armnn::DataType::Float32);
@@ -290,33 +322,7 @@ BOOST_AUTO_TEST_CASE(SerializeAddition)
 
 BOOST_AUTO_TEST_CASE(SerializeArgMinMax)
 {
-    class ArgMinMaxLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        ArgMinMaxLayerVerifier(const std::string& layerName,
-                               const std::vector<armnn::TensorInfo>& inputInfos,
-                               const std::vector<armnn::TensorInfo>& outputInfos,
-                               const armnn::ArgMinMaxDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitArgMinMaxLayer(const armnn::IConnectableLayer* layer,
-                                 const armnn::ArgMinMaxDescriptor& descriptor,
-                                 const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::ArgMinMaxDescriptor& descriptor)
-        {
-            BOOST_CHECK(descriptor.m_Function == m_Descriptor.m_Function);
-            BOOST_CHECK(descriptor.m_Axis == m_Descriptor.m_Axis);
-        }
-
-        armnn::ArgMinMaxDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(ArgMinMax)
 
     const std::string layerName("argminmax");
     const armnn::TensorInfo inputInfo({1, 2, 3}, armnn::DataType::Float32);
@@ -346,26 +352,26 @@ BOOST_AUTO_TEST_CASE(SerializeArgMinMax)
 
 BOOST_AUTO_TEST_CASE(SerializeBatchNormalization)
 {
-    class BatchNormalizationLayerVerifier : public LayerVerifierBase
+    using Descriptor = armnn::BatchNormalizationDescriptor;
+    class BatchNormalizationLayerVerifier : public LayerVerifierBaseWithDescriptor<Descriptor>
     {
     public:
         BatchNormalizationLayerVerifier(const std::string& layerName,
                                         const std::vector<armnn::TensorInfo>& inputInfos,
                                         const std::vector<armnn::TensorInfo>& outputInfos,
-                                        const armnn::BatchNormalizationDescriptor& descriptor,
+                                        const Descriptor& descriptor,
                                         const armnn::ConstTensor& mean,
                                         const armnn::ConstTensor& variance,
                                         const armnn::ConstTensor& beta,
                                         const armnn::ConstTensor& gamma)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor)
-        , m_Mean(mean)
-        , m_Variance(variance)
-        , m_Beta(beta)
-        , m_Gamma(gamma) {}
+            : LayerVerifierBaseWithDescriptor<Descriptor>(layerName, inputInfos, outputInfos, descriptor)
+            , m_Mean(mean)
+            , m_Variance(variance)
+            , m_Beta(beta)
+            , m_Gamma(gamma) {}
 
         void VisitBatchNormalizationLayer(const armnn::IConnectableLayer* layer,
-                                          const armnn::BatchNormalizationDescriptor& descriptor,
+                                          const Descriptor& descriptor,
                                           const armnn::ConstTensor& mean,
                                           const armnn::ConstTensor& variance,
                                           const armnn::ConstTensor& beta,
@@ -382,13 +388,6 @@ BOOST_AUTO_TEST_CASE(SerializeBatchNormalization)
         }
 
     private:
-        void VerifyDescriptor(const armnn::BatchNormalizationDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_Eps == m_Descriptor.m_Eps);
-            BOOST_TEST(static_cast<int>(descriptor.m_DataLayout) == static_cast<int>(m_Descriptor.m_DataLayout));
-        }
-
-        armnn::BatchNormalizationDescriptor m_Descriptor;
         armnn::ConstTensor m_Mean;
         armnn::ConstTensor m_Variance;
         armnn::ConstTensor m_Beta;
@@ -440,34 +439,7 @@ BOOST_AUTO_TEST_CASE(SerializeBatchNormalization)
 
 BOOST_AUTO_TEST_CASE(SerializeBatchToSpaceNd)
 {
-    class BatchToSpaceNdLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        BatchToSpaceNdLayerVerifier(const std::string& layerName,
-                                    const std::vector<armnn::TensorInfo>& inputInfos,
-                                    const std::vector<armnn::TensorInfo>& outputInfos,
-                                    const armnn::BatchToSpaceNdDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitBatchToSpaceNdLayer(const armnn::IConnectableLayer* layer,
-                                      const armnn::BatchToSpaceNdDescriptor& descriptor,
-                                      const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::BatchToSpaceNdDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_Crops == m_Descriptor.m_Crops);
-            BOOST_TEST(descriptor.m_BlockShape == m_Descriptor.m_BlockShape);
-            BOOST_TEST(GetDataLayoutName(descriptor.m_DataLayout) == GetDataLayoutName(m_Descriptor.m_DataLayout));
-        }
-
-        armnn::BatchToSpaceNdDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(BatchToSpaceNd)
 
     const std::string layerName("spaceToBatchNd");
     const armnn::TensorInfo inputInfo({4, 1, 2, 2}, armnn::DataType::Float32);
@@ -496,6 +468,40 @@ BOOST_AUTO_TEST_CASE(SerializeBatchToSpaceNd)
     deserializedNetwork->Accept(verifier);
 }
 
+BOOST_AUTO_TEST_CASE(SerializeComparison)
+{
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Comparison)
+
+    const std::string layerName("comparison");
+
+    const armnn::TensorShape shape{2, 1, 2, 4};
+
+    const armnn::TensorInfo inputInfo  = armnn::TensorInfo(shape, armnn::DataType::Float32);
+    const armnn::TensorInfo outputInfo = armnn::TensorInfo(shape, armnn::DataType::Boolean);
+
+    armnn::ComparisonDescriptor descriptor(armnn::ComparisonOperation::NotEqual);
+
+    armnn::INetworkPtr network = armnn::INetwork::Create();
+    armnn::IConnectableLayer* const inputLayer0     = network->AddInputLayer(0);
+    armnn::IConnectableLayer* const inputLayer1     = network->AddInputLayer(1);
+    armnn::IConnectableLayer* const comparisonLayer = network->AddComparisonLayer(descriptor, layerName.c_str());
+    armnn::IConnectableLayer* const outputLayer     = network->AddOutputLayer(0);
+
+    inputLayer0->GetOutputSlot(0).Connect(comparisonLayer->GetInputSlot(0));
+    inputLayer1->GetOutputSlot(0).Connect(comparisonLayer->GetInputSlot(1));
+    comparisonLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
+
+    inputLayer0->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    inputLayer1->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    comparisonLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
+
+    armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
+    BOOST_CHECK(deserializedNetwork);
+
+    ComparisonLayerVerifier verifier(layerName, { inputInfo, inputInfo }, { outputInfo }, descriptor);
+    deserializedNetwork->Accept(verifier);
+}
+
 BOOST_AUTO_TEST_CASE(SerializeConstant)
 {
     class ConstantLayerVerifier : public LayerVerifierBase
@@ -505,15 +511,14 @@ BOOST_AUTO_TEST_CASE(SerializeConstant)
                               const std::vector<armnn::TensorInfo>& inputInfos,
                               const std::vector<armnn::TensorInfo>& outputInfos,
                               const armnn::ConstTensor& layerInput)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_LayerInput(layerInput) {}
+            : LayerVerifierBase(layerName, inputInfos, outputInfos)
+            , m_LayerInput(layerInput) {}
 
         void VisitConstantLayer(const armnn::IConnectableLayer* layer,
                                 const armnn::ConstTensor& input,
                                 const char* name) override
         {
             VerifyNameAndConnections(layer, name);
-
             CompareConstTensor(input, m_LayerInput);
         }
 
@@ -552,23 +557,22 @@ BOOST_AUTO_TEST_CASE(SerializeConstant)
 
 BOOST_AUTO_TEST_CASE(SerializeConvolution2d)
 {
-    class Convolution2dLayerVerifier : public LayerVerifierBase
+    using Descriptor = armnn::Convolution2dDescriptor;
+    class Convolution2dLayerVerifier : public LayerVerifierBaseWithDescriptor<Descriptor>
     {
     public:
         Convolution2dLayerVerifier(const std::string& layerName,
                                    const std::vector<armnn::TensorInfo>& inputInfos,
                                    const std::vector<armnn::TensorInfo>& outputInfos,
-                                   const armnn::Convolution2dDescriptor& descriptor,
+                                   const Descriptor& descriptor,
                                    const armnn::ConstTensor& weights,
-                                   const armnn::Optional<armnn::ConstTensor>& biases) :
-            LayerVerifierBase(layerName, inputInfos, outputInfos),
-            m_Descriptor(descriptor),
-            m_Weights(weights),
-            m_Biases(biases)
-        {}
+                                   const armnn::Optional<armnn::ConstTensor>& biases)
+            : LayerVerifierBaseWithDescriptor<Descriptor>(layerName, inputInfos, outputInfos, descriptor)
+            , m_Weights(weights)
+            , m_Biases(biases) {}
 
         void VisitConvolution2dLayer(const armnn::IConnectableLayer* layer,
-                                     const armnn::Convolution2dDescriptor& descriptor,
+                                     const Descriptor& descriptor,
                                      const armnn::ConstTensor& weights,
                                      const armnn::Optional<armnn::ConstTensor>& biases,
                                      const char* name) override
@@ -580,9 +584,7 @@ BOOST_AUTO_TEST_CASE(SerializeConvolution2d)
             CompareConstTensor(weights, m_Weights);
 
             // check biases
-            BOOST_CHECK(biases.has_value()   == descriptor.m_BiasEnabled);
-            BOOST_CHECK(m_Biases.has_value() == m_Descriptor.m_BiasEnabled);
-
+            BOOST_CHECK(biases.has_value() == descriptor.m_BiasEnabled);
             BOOST_CHECK(biases.has_value() == m_Biases.has_value());
 
             if (biases.has_value() && m_Biases.has_value())
@@ -592,21 +594,6 @@ BOOST_AUTO_TEST_CASE(SerializeConvolution2d)
         }
 
     private:
-        void VerifyDescriptor(const armnn::Convolution2dDescriptor& descriptor)
-        {
-            BOOST_CHECK(descriptor.m_PadLeft     == m_Descriptor.m_PadLeft);
-            BOOST_CHECK(descriptor.m_PadRight    == m_Descriptor.m_PadRight);
-            BOOST_CHECK(descriptor.m_PadTop      == m_Descriptor.m_PadTop);
-            BOOST_CHECK(descriptor.m_PadBottom   == m_Descriptor.m_PadBottom);
-            BOOST_CHECK(descriptor.m_StrideX     == m_Descriptor.m_StrideX);
-            BOOST_CHECK(descriptor.m_StrideY     == m_Descriptor.m_StrideY);
-            BOOST_CHECK(descriptor.m_DilationX   == m_Descriptor.m_DilationX);
-            BOOST_CHECK(descriptor.m_DilationY   == m_Descriptor.m_DilationY);
-            BOOST_CHECK(descriptor.m_BiasEnabled == m_Descriptor.m_BiasEnabled);
-            BOOST_CHECK(descriptor.m_DataLayout  == m_Descriptor.m_DataLayout);
-        }
-
-        armnn::Convolution2dDescriptor      m_Descriptor;
         armnn::ConstTensor                  m_Weights;
         armnn::Optional<armnn::ConstTensor> m_Biases;
     };
@@ -660,33 +647,7 @@ BOOST_AUTO_TEST_CASE(SerializeConvolution2d)
 
 BOOST_AUTO_TEST_CASE(SerializeDepthToSpace)
 {
-    class DepthToSpaceLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        DepthToSpaceLayerVerifier(const std::string& layerName,
-                                  const std::vector<armnn::TensorInfo>& inputInfos,
-                                  const std::vector<armnn::TensorInfo>& outputInfos,
-                                  const armnn::DepthToSpaceDescriptor& descriptor)
-            : LayerVerifierBase(layerName, inputInfos, outputInfos)
-            , m_Descriptor(descriptor) {}
-
-        void VisitDepthToSpaceLayer(const armnn::IConnectableLayer* layer,
-                                    const armnn::DepthToSpaceDescriptor& descriptor,
-                                    const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::DepthToSpaceDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_BlockSize == m_Descriptor.m_BlockSize);
-            BOOST_TEST(GetDataLayoutName(descriptor.m_DataLayout) == GetDataLayoutName(m_Descriptor.m_DataLayout));
-        }
-
-        armnn::DepthToSpaceDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(DepthToSpace)
 
     const std::string layerName("depthToSpace");
 
@@ -717,23 +678,22 @@ BOOST_AUTO_TEST_CASE(SerializeDepthToSpace)
 
 BOOST_AUTO_TEST_CASE(SerializeDepthwiseConvolution2d)
 {
-    class DepthwiseConvolution2dLayerVerifier : public LayerVerifierBase
+    using Descriptor = armnn::DepthwiseConvolution2dDescriptor;
+    class DepthwiseConvolution2dLayerVerifier : public LayerVerifierBaseWithDescriptor<Descriptor>
     {
     public:
         DepthwiseConvolution2dLayerVerifier(const std::string& layerName,
                                             const std::vector<armnn::TensorInfo>& inputInfos,
                                             const std::vector<armnn::TensorInfo>& outputInfos,
-                                            const armnn::DepthwiseConvolution2dDescriptor& descriptor,
+                                            const Descriptor& descriptor,
                                             const armnn::ConstTensor& weights,
                                             const armnn::Optional<armnn::ConstTensor>& biases) :
-            LayerVerifierBase(layerName, inputInfos, outputInfos),
-            m_Descriptor(descriptor),
+            LayerVerifierBaseWithDescriptor<Descriptor>(layerName, inputInfos, outputInfos, descriptor),
             m_Weights(weights),
-            m_Biases(biases)
-        {}
+            m_Biases(biases) {}
 
         void VisitDepthwiseConvolution2dLayer(const armnn::IConnectableLayer* layer,
-                                              const armnn::DepthwiseConvolution2dDescriptor& descriptor,
+                                              const Descriptor& descriptor,
                                               const armnn::ConstTensor& weights,
                                               const armnn::Optional<armnn::ConstTensor>& biases,
                                               const char* name) override
@@ -745,9 +705,7 @@ BOOST_AUTO_TEST_CASE(SerializeDepthwiseConvolution2d)
             CompareConstTensor(weights, m_Weights);
 
             // check biases
-            BOOST_CHECK(biases.has_value()   == descriptor.m_BiasEnabled);
-            BOOST_CHECK(m_Biases.has_value() == m_Descriptor.m_BiasEnabled);
-
+            BOOST_CHECK(biases.has_value() == descriptor.m_BiasEnabled);
             BOOST_CHECK(biases.has_value() == m_Biases.has_value());
 
             if (biases.has_value() && m_Biases.has_value())
@@ -757,21 +715,6 @@ BOOST_AUTO_TEST_CASE(SerializeDepthwiseConvolution2d)
         }
 
     private:
-        void VerifyDescriptor(const armnn::DepthwiseConvolution2dDescriptor& descriptor)
-        {
-            BOOST_CHECK(descriptor.m_PadLeft     == m_Descriptor.m_PadLeft);
-            BOOST_CHECK(descriptor.m_PadRight    == m_Descriptor.m_PadRight);
-            BOOST_CHECK(descriptor.m_PadTop      == m_Descriptor.m_PadTop);
-            BOOST_CHECK(descriptor.m_PadBottom   == m_Descriptor.m_PadBottom);
-            BOOST_CHECK(descriptor.m_StrideX     == m_Descriptor.m_StrideX);
-            BOOST_CHECK(descriptor.m_StrideY     == m_Descriptor.m_StrideY);
-            BOOST_CHECK(descriptor.m_DilationX   == m_Descriptor.m_DilationX);
-            BOOST_CHECK(descriptor.m_DilationY   == m_Descriptor.m_DilationY);
-            BOOST_CHECK(descriptor.m_BiasEnabled == m_Descriptor.m_BiasEnabled);
-            BOOST_CHECK(descriptor.m_DataLayout  == m_Descriptor.m_DataLayout);
-        }
-
-        armnn::DepthwiseConvolution2dDescriptor m_Descriptor;
         armnn::ConstTensor                      m_Weights;
         armnn::Optional<armnn::ConstTensor>     m_Biases;
     };
@@ -825,19 +768,7 @@ BOOST_AUTO_TEST_CASE(SerializeDepthwiseConvolution2d)
 
 BOOST_AUTO_TEST_CASE(SerializeDequantize)
 {
-    class DequantizeLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        DequantizeLayerVerifier(const std::string& layerName,
-                                const std::vector<armnn::TensorInfo>& inputInfos,
-                                const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitDequantizeLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Dequantize)
 
     const std::string layerName("dequantize");
     const armnn::TensorInfo inputInfo({ 1, 5, 2, 3 }, armnn::DataType::QuantisedAsymm8, 0.5f, 1);
@@ -863,20 +794,20 @@ BOOST_AUTO_TEST_CASE(SerializeDequantize)
 
 BOOST_AUTO_TEST_CASE(SerializeDeserializeDetectionPostProcess)
 {
-    class DetectionPostProcessLayerVerifier : public LayerVerifierBase
+    using Descriptor = armnn::DetectionPostProcessDescriptor;
+    class DetectionPostProcessLayerVerifier : public LayerVerifierBaseWithDescriptor<Descriptor>
     {
     public:
         DetectionPostProcessLayerVerifier(const std::string& layerName,
                                           const std::vector<armnn::TensorInfo>& inputInfos,
                                           const std::vector<armnn::TensorInfo>& outputInfos,
-                                          const armnn::DetectionPostProcessDescriptor& descriptor,
+                                          const Descriptor& descriptor,
                                           const armnn::ConstTensor& anchors)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor)
-        , m_Anchors(anchors) {}
+            : LayerVerifierBaseWithDescriptor<Descriptor>(layerName, inputInfos, outputInfos, descriptor)
+            , m_Anchors(anchors) {}
 
         void VisitDetectionPostProcessLayer(const armnn::IConnectableLayer* layer,
-                                            const armnn::DetectionPostProcessDescriptor& descriptor,
+                                            const Descriptor& descriptor,
                                             const armnn::ConstTensor& anchors,
                                             const char* name) override
         {
@@ -887,22 +818,6 @@ BOOST_AUTO_TEST_CASE(SerializeDeserializeDetectionPostProcess)
         }
 
     private:
-        void VerifyDescriptor(const armnn::DetectionPostProcessDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_UseRegularNms == m_Descriptor.m_UseRegularNms);
-            BOOST_TEST(descriptor.m_MaxDetections == m_Descriptor.m_MaxDetections);
-            BOOST_TEST(descriptor.m_MaxClassesPerDetection == m_Descriptor.m_MaxClassesPerDetection);
-            BOOST_TEST(descriptor.m_DetectionsPerClass == m_Descriptor.m_DetectionsPerClass);
-            BOOST_TEST(descriptor.m_NmsScoreThreshold == m_Descriptor.m_NmsScoreThreshold);
-            BOOST_TEST(descriptor.m_NmsIouThreshold == m_Descriptor.m_NmsIouThreshold);
-            BOOST_TEST(descriptor.m_NumClasses == m_Descriptor.m_NumClasses);
-            BOOST_TEST(descriptor.m_ScaleY == m_Descriptor.m_ScaleY);
-            BOOST_TEST(descriptor.m_ScaleX == m_Descriptor.m_ScaleX);
-            BOOST_TEST(descriptor.m_ScaleH == m_Descriptor.m_ScaleH);
-            BOOST_TEST(descriptor.m_ScaleW == m_Descriptor.m_ScaleW);
-        }
-
-        armnn::DetectionPostProcessDescriptor m_Descriptor;
         armnn::ConstTensor m_Anchors;
     };
 
@@ -971,19 +886,7 @@ BOOST_AUTO_TEST_CASE(SerializeDeserializeDetectionPostProcess)
 
 BOOST_AUTO_TEST_CASE(SerializeDivision)
 {
-    class DivisionLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        DivisionLayerVerifier(const std::string& layerName,
-                              const std::vector<armnn::TensorInfo>& inputInfos,
-                              const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitDivisionLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Division)
 
     const std::string layerName("division");
     const armnn::TensorInfo info({ 1, 5, 2, 3 }, armnn::DataType::Float32);
@@ -1009,22 +912,67 @@ BOOST_AUTO_TEST_CASE(SerializeDivision)
     deserializedNetwork->Accept(verifier);
 }
 
-BOOST_AUTO_TEST_CASE(SerializeFloor)
+// NOTE: Until the deprecated AddEqualLayer disappears this test checks that calling
+//       AddEqualLayer places a ComparisonLayer into the serialized format and that
+//       when this deserialises we have a ComparisonLayer
+BOOST_AUTO_TEST_CASE(SerializeEqual)
 {
-    class FloorLayerVerifier : public LayerVerifierBase
+    class EqualLayerVerifier : public LayerVerifierBase
     {
     public:
-        FloorLayerVerifier(const std::string& layerName,
+        EqualLayerVerifier(const std::string& layerName,
                            const std::vector<armnn::TensorInfo>& inputInfos,
                            const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
+            : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
 
-        void VisitFloorLayer(const armnn::IConnectableLayer* layer, const char* name) override
+        void VisitComparisonLayer(const armnn::IConnectableLayer* layer,
+                                  const armnn::ComparisonDescriptor& descriptor,
+                                  const char* name) override
         {
             VerifyNameAndConnections(layer, name);
+            BOOST_CHECK(descriptor.m_Operation == armnn::ComparisonOperation::Equal);
+        }
+
+        void VisitEqualLayer(const armnn::IConnectableLayer* layer, const char* name) override
+        {
+            throw armnn::Exception("EqualLayer should have translated to ComparisonLayer");
         }
     };
 
+    const std::string layerName("equal");
+
+    const armnn::TensorShape shape{2, 1, 2, 4};
+
+    const armnn::TensorInfo inputInfo  = armnn::TensorInfo(shape, armnn::DataType::Float32);
+    const armnn::TensorInfo outputInfo = armnn::TensorInfo(shape, armnn::DataType::Boolean);
+
+    armnn::INetworkPtr network = armnn::INetwork::Create();
+    armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
+    armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
+    ARMNN_NO_DEPRECATE_WARN_BEGIN
+    armnn::IConnectableLayer* const equalLayer = network->AddEqualLayer(layerName.c_str());
+    ARMNN_NO_DEPRECATE_WARN_END
+    armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
+
+    inputLayer0->GetOutputSlot(0).Connect(equalLayer->GetInputSlot(0));
+    inputLayer1->GetOutputSlot(0).Connect(equalLayer->GetInputSlot(1));
+    equalLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
+
+    inputLayer0->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    inputLayer1->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    equalLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
+
+    armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
+    BOOST_CHECK(deserializedNetwork);
+
+    EqualLayerVerifier verifier(layerName, { inputInfo, inputInfo }, { outputInfo });
+    deserializedNetwork->Accept(verifier);
+}
+
+BOOST_AUTO_TEST_CASE(SerializeFloor)
+{
+    DECLARE_LAYER_VERIFIER_CLASS(Floor)
+
     const std::string layerName("floor");
     const armnn::TensorInfo info({4,4}, armnn::DataType::Float32);
 
@@ -1048,22 +996,22 @@ BOOST_AUTO_TEST_CASE(SerializeFloor)
 
 BOOST_AUTO_TEST_CASE(SerializeFullyConnected)
 {
-    class FullyConnectedLayerVerifier : public LayerVerifierBase
+    using Descriptor = armnn::FullyConnectedDescriptor;
+    class FullyConnectedLayerVerifier : public LayerVerifierBaseWithDescriptor<Descriptor>
     {
     public:
         FullyConnectedLayerVerifier(const std::string& layerName,
                                     const std::vector<armnn::TensorInfo>& inputInfos,
                                     const std::vector<armnn::TensorInfo>& outputInfos,
-                                    const armnn::FullyConnectedDescriptor& descriptor,
+                                    const Descriptor& descriptor,
                                     const armnn::ConstTensor& weight,
                                     const armnn::Optional<armnn::ConstTensor>& bias)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor)
-        , m_Weight(weight)
-        , m_Bias(bias) {}
+            : LayerVerifierBaseWithDescriptor<Descriptor>(layerName, inputInfos, outputInfos, descriptor)
+            , m_Weight(weight)
+            , m_Bias(bias) {}
 
         void VisitFullyConnectedLayer(const armnn::IConnectableLayer* layer,
-                                      const armnn::FullyConnectedDescriptor& descriptor,
+                                      const Descriptor& descriptor,
                                       const armnn::ConstTensor& weight,
                                       const armnn::Optional<armnn::ConstTensor>& bias,
                                       const char* name) override
@@ -1073,7 +1021,9 @@ BOOST_AUTO_TEST_CASE(SerializeFullyConnected)
 
             CompareConstTensor(weight, m_Weight);
 
+            BOOST_TEST(bias.has_value() == descriptor.m_BiasEnabled);
             BOOST_TEST(bias.has_value() == m_Bias.has_value());
+
             if (bias.has_value() && m_Bias.has_value())
             {
                 CompareConstTensor(bias.value(), m_Bias.value());
@@ -1081,13 +1031,6 @@ BOOST_AUTO_TEST_CASE(SerializeFullyConnected)
         }
 
     private:
-        void VerifyDescriptor(const armnn::FullyConnectedDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_BiasEnabled == m_Descriptor.m_BiasEnabled);
-            BOOST_TEST(descriptor.m_TransposeWeightMatrix == m_Descriptor.m_TransposeWeightMatrix);
-        }
-
-        armnn::FullyConnectedDescriptor m_Descriptor;
         armnn::ConstTensor m_Weight;
         armnn::Optional<armnn::ConstTensor> m_Bias;
     };
@@ -1137,7 +1080,7 @@ BOOST_AUTO_TEST_CASE(SerializeGather)
         GatherLayerVerifier(const std::string& layerName,
                             const std::vector<armnn::TensorInfo>& inputInfos,
                             const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
+            : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
 
         void VisitGatherLayer(const armnn::IConnectableLayer* layer, const char *name) override
         {
@@ -1183,38 +1126,67 @@ BOOST_AUTO_TEST_CASE(SerializeGather)
     deserializedNetwork->Accept(verifier);
 }
 
-BOOST_AUTO_TEST_CASE(SerializeInstanceNormalization)
+// NOTE: Until the deprecated AddGreaterLayer disappears this test checks that calling
+//       AddGreaterLayer places a ComparisonLayer into the serialized format and that
+//       when this deserialises we have a ComparisonLayer
+BOOST_AUTO_TEST_CASE(SerializeGreater)
 {
-    class InstanceNormalizationLayerVerifier : public LayerVerifierBase
+    class GreaterLayerVerifier : public LayerVerifierBase
     {
     public:
-        InstanceNormalizationLayerVerifier(const std::string& layerName,
-                                           const std::vector<armnn::TensorInfo>& inputInfos,
-                                           const std::vector<armnn::TensorInfo>& outputInfos,
-                                           const armnn::InstanceNormalizationDescriptor& descriptor)
-            : LayerVerifierBase(layerName, inputInfos, outputInfos)
-            , m_Descriptor(descriptor) {}
+        GreaterLayerVerifier(const std::string& layerName,
+                           const std::vector<armnn::TensorInfo>& inputInfos,
+                           const std::vector<armnn::TensorInfo>& outputInfos)
+            : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
 
-        void VisitInstanceNormalizationLayer(const armnn::IConnectableLayer* layer,
-                                             const armnn::InstanceNormalizationDescriptor& descriptor,
-                                             const char* name) override
+        void VisitComparisonLayer(const armnn::IConnectableLayer* layer,
+                                  const armnn::ComparisonDescriptor& descriptor,
+                                  const char* name) override
         {
             VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
+            BOOST_CHECK(descriptor.m_Operation == armnn::ComparisonOperation::Greater);
         }
 
-    private:
-        void VerifyDescriptor(const armnn::InstanceNormalizationDescriptor& descriptor)
+        void VisitGreaterLayer(const armnn::IConnectableLayer* layer, const char* name) override
         {
-            BOOST_CHECK(descriptor.m_Gamma      == m_Descriptor.m_Gamma);
-            BOOST_CHECK(descriptor.m_Beta       == m_Descriptor.m_Beta);
-            BOOST_CHECK(descriptor.m_Eps        == m_Descriptor.m_Eps);
-            BOOST_CHECK(descriptor.m_DataLayout == m_Descriptor.m_DataLayout);
+            throw armnn::Exception("GreaterLayer should have translated to ComparisonLayer");
         }
-
-        armnn::InstanceNormalizationDescriptor m_Descriptor;
     };
 
+    const std::string layerName("greater");
+
+    const armnn::TensorShape shape{2, 1, 2, 4};
+
+    const armnn::TensorInfo inputInfo  = armnn::TensorInfo(shape, armnn::DataType::Float32);
+    const armnn::TensorInfo outputInfo = armnn::TensorInfo(shape, armnn::DataType::Boolean);
+
+    armnn::INetworkPtr network = armnn::INetwork::Create();
+    armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
+    armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
+    ARMNN_NO_DEPRECATE_WARN_BEGIN
+    armnn::IConnectableLayer* const equalLayer = network->AddGreaterLayer(layerName.c_str());
+    ARMNN_NO_DEPRECATE_WARN_END
+    armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
+
+    inputLayer0->GetOutputSlot(0).Connect(equalLayer->GetInputSlot(0));
+    inputLayer1->GetOutputSlot(0).Connect(equalLayer->GetInputSlot(1));
+    equalLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
+
+    inputLayer0->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    inputLayer1->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    equalLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
+
+    armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
+    BOOST_CHECK(deserializedNetwork);
+
+    GreaterLayerVerifier verifier(layerName, { inputInfo, inputInfo }, { outputInfo });
+    deserializedNetwork->Accept(verifier);
+}
+
+BOOST_AUTO_TEST_CASE(SerializeInstanceNormalization)
+{
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(InstanceNormalization)
+
     const std::string layerName("instanceNormalization");
     const armnn::TensorInfo info({ 1, 2, 1, 5 }, armnn::DataType::Float32);
 
@@ -1243,32 +1215,7 @@ BOOST_AUTO_TEST_CASE(SerializeInstanceNormalization)
     deserializedNetwork->Accept(verifier);
 }
 
-class L2NormalizationLayerVerifier : public LayerVerifierBase
-{
-public:
-    L2NormalizationLayerVerifier(const std::string& layerName,
-                                 const std::vector<armnn::TensorInfo>& inputInfos,
-                                 const std::vector<armnn::TensorInfo>& outputInfos,
-                                 const armnn::L2NormalizationDescriptor& descriptor)
-            : LayerVerifierBase(layerName, inputInfos, outputInfos)
-            , m_Descriptor(descriptor) {}
-
-    void VisitL2NormalizationLayer(const armnn::IConnectableLayer* layer,
-                                   const armnn::L2NormalizationDescriptor& descriptor,
-                                   const char* name) override
-    {
-        VerifyNameAndConnections(layer, name);
-        VerifyDescriptor(descriptor);
-    }
-private:
-    void VerifyDescriptor(const armnn::L2NormalizationDescriptor& descriptor)
-    {
-        BOOST_TEST(descriptor.m_Eps == m_Descriptor.m_Eps);
-        BOOST_TEST(GetDataLayoutName(descriptor.m_DataLayout) == GetDataLayoutName(m_Descriptor.m_DataLayout));
-    }
-
-    armnn::L2NormalizationDescriptor m_Descriptor;
-};
+DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(L2Normalization)
 
 BOOST_AUTO_TEST_CASE(SerializeL2Normalization)
 {
@@ -1355,33 +1302,7 @@ BOOST_AUTO_TEST_CASE(EnsureL2NormalizationBackwardCompatibility)
 
 BOOST_AUTO_TEST_CASE(SerializeLogSoftmax)
 {
-    class LogSoftmaxLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        LogSoftmaxLayerVerifier(const std::string& layerName,
-                                const std::vector<armnn::TensorInfo>& inputInfos,
-                                const std::vector<armnn::TensorInfo>& outputInfos,
-                                const armnn::LogSoftmaxDescriptor& descriptor)
-            : LayerVerifierBase(layerName, inputInfos, outputInfos)
-            , m_Descriptor(descriptor) {}
-
-        void VisitLogSoftmaxLayer(const armnn::IConnectableLayer* layer,
-                                  const armnn::LogSoftmaxDescriptor& descriptor,
-                                  const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::LogSoftmaxDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_Beta == m_Descriptor.m_Beta);
-            BOOST_TEST(descriptor.m_Axis == m_Descriptor.m_Axis);
-        }
-
-        armnn::LogSoftmaxDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(LogSoftmax)
 
     const std::string layerName("log_softmax");
     const armnn::TensorInfo info({1, 10}, armnn::DataType::Float32);
@@ -1410,19 +1331,7 @@ BOOST_AUTO_TEST_CASE(SerializeLogSoftmax)
 
 BOOST_AUTO_TEST_CASE(SerializeMaximum)
 {
-    class MaximumLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        MaximumLayerVerifier(const std::string& layerName,
-                             const std::vector<armnn::TensorInfo>& inputInfos,
-                             const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitMaximumLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Maximum)
 
     const std::string layerName("maximum");
     const armnn::TensorInfo info({ 1, 2, 2, 3 }, armnn::DataType::Float32);
@@ -1450,33 +1359,7 @@ BOOST_AUTO_TEST_CASE(SerializeMaximum)
 
 BOOST_AUTO_TEST_CASE(SerializeMean)
 {
-    class MeanLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        MeanLayerVerifier(const std::string& layerName,
-                          const std::vector<armnn::TensorInfo>& inputInfos,
-                          const std::vector<armnn::TensorInfo>& outputInfos,
-                          const armnn::MeanDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitMeanLayer(const armnn::IConnectableLayer* layer,
-                            const armnn::MeanDescriptor& descriptor,
-                            const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::MeanDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_Axis == m_Descriptor.m_Axis);
-            BOOST_TEST(descriptor.m_KeepDims == m_Descriptor.m_KeepDims);
-        }
-
-        armnn::MeanDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Mean)
 
     const std::string layerName("mean");
     const armnn::TensorInfo inputInfo({1, 1, 3, 2}, armnn::DataType::Float32);
@@ -1506,19 +1389,7 @@ BOOST_AUTO_TEST_CASE(SerializeMean)
 
 BOOST_AUTO_TEST_CASE(SerializeMerge)
 {
-    class MergeLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        MergeLayerVerifier(const std::string& layerName,
-                           const std::vector<armnn::TensorInfo>& inputInfos,
-                           const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitMergeLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Merge)
 
     const std::string layerName("merge");
     const armnn::TensorInfo info({ 1, 2, 2, 3 }, armnn::DataType::Float32);
@@ -1544,15 +1415,14 @@ BOOST_AUTO_TEST_CASE(SerializeMerge)
     deserializedNetwork->Accept(verifier);
 }
 
-class MergerLayerVerifier : public LayerVerifierBase
+class MergerLayerVerifier : public LayerVerifierBaseWithDescriptor<armnn::OriginsDescriptor>
 {
 public:
     MergerLayerVerifier(const std::string& layerName,
                         const std::vector<armnn::TensorInfo>& inputInfos,
                         const std::vector<armnn::TensorInfo>& outputInfos,
                         const armnn::OriginsDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
+        : LayerVerifierBaseWithDescriptor<armnn::OriginsDescriptor>(layerName, inputInfos, outputInfos, descriptor) {}
 
     void VisitMergerLayer(const armnn::IConnectableLayer* layer,
                           const armnn::OriginsDescriptor& descriptor,
@@ -1568,27 +1438,9 @@ public:
         VerifyNameAndConnections(layer, name);
         VerifyDescriptor(descriptor);
     }
-
-private:
-    void VerifyDescriptor(const armnn::OriginsDescriptor& descriptor)
-    {
-        BOOST_TEST(descriptor.GetConcatAxis() == m_Descriptor.GetConcatAxis());
-        BOOST_TEST(descriptor.GetNumViews() == m_Descriptor.GetNumViews());
-        BOOST_TEST(descriptor.GetNumDimensions() == m_Descriptor.GetNumDimensions());
-
-        for (uint32_t i = 0; i < descriptor.GetNumViews(); i++)
-        {
-            for (uint32_t j = 0; j < descriptor.GetNumDimensions(); j++)
-            {
-                BOOST_TEST(descriptor.GetViewOrigin(i)[j] == m_Descriptor.GetViewOrigin(i)[j]);
-            }
-        }
-    }
-
-    armnn::OriginsDescriptor m_Descriptor;
 };
 
-// NOTE: until the deprecated AddMergerLayer disappears this test checks that calling
+// NOTE: Until the deprecated AddMergerLayer disappears this test checks that calling
 //       AddMergerLayer places a ConcatLayer into the serialized format and that
 //       when this deserialises we have a ConcatLayer
 BOOST_AUTO_TEST_CASE(SerializeMerger)
@@ -1731,19 +1583,7 @@ BOOST_AUTO_TEST_CASE(SerializeConcat)
 
 BOOST_AUTO_TEST_CASE(SerializeMinimum)
 {
-    class MinimumLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        MinimumLayerVerifier(const std::string& layerName,
-                             const std::vector<armnn::TensorInfo>& inputInfos,
-                             const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitMinimumLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Minimum)
 
     const std::string layerName("minimum");
     const armnn::TensorInfo info({ 1, 2, 2, 3 }, armnn::DataType::Float32);
@@ -1771,19 +1611,7 @@ BOOST_AUTO_TEST_CASE(SerializeMinimum)
 
 BOOST_AUTO_TEST_CASE(SerializeMultiplication)
 {
-    class MultiplicationLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        MultiplicationLayerVerifier(const std::string& layerName,
-                                    const std::vector<armnn::TensorInfo>& inputInfos,
-                                    const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitMultiplicationLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Multiplication)
 
     const std::string layerName("multiplication");
     const armnn::TensorInfo info({ 1, 5, 2, 3 }, armnn::DataType::Float32);
@@ -1811,19 +1639,7 @@ BOOST_AUTO_TEST_CASE(SerializeMultiplication)
 
 BOOST_AUTO_TEST_CASE(SerializePrelu)
 {
-    class PreluLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        PreluLayerVerifier(const std::string& layerName,
-                           const std::vector<armnn::TensorInfo>& inputInfos,
-                           const std::vector<armnn::TensorInfo>& outputInfos)
-            : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitPreluLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Prelu)
 
     const std::string layerName("prelu");
 
@@ -1854,40 +1670,7 @@ BOOST_AUTO_TEST_CASE(SerializePrelu)
 
 BOOST_AUTO_TEST_CASE(SerializeNormalization)
 {
-    class NormalizationLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        NormalizationLayerVerifier(const std::string& layerName,
-                                   const std::vector<armnn::TensorInfo>& inputInfos,
-                                   const std::vector<armnn::TensorInfo>& outputInfos,
-                                   const armnn::NormalizationDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitNormalizationLayer(const armnn::IConnectableLayer* layer,
-                                     const armnn::NormalizationDescriptor& descriptor,
-                                     const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::NormalizationDescriptor& descriptor)
-        {
-            BOOST_TEST(GetDataLayoutName(descriptor.m_DataLayout) == GetDataLayoutName(m_Descriptor.m_DataLayout));
-            BOOST_TEST(descriptor.m_NormSize == m_Descriptor.m_NormSize);
-            BOOST_TEST(descriptor.m_Alpha == m_Descriptor.m_Alpha);
-            BOOST_TEST(descriptor.m_Beta == m_Descriptor.m_Beta);
-            BOOST_TEST(descriptor.m_K == m_Descriptor.m_K);
-            BOOST_TEST(
-                static_cast<int>(descriptor.m_NormChannelType) == static_cast<int>(m_Descriptor.m_NormChannelType));
-            BOOST_TEST(
-                static_cast<int>(descriptor.m_NormMethodType) == static_cast<int>(m_Descriptor.m_NormMethodType));
-        }
-
-        armnn::NormalizationDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Normalization)
 
     const std::string layerName("normalization");
     const armnn::TensorInfo info({2, 1, 2, 2}, armnn::DataType::Float32);
@@ -1917,36 +1700,10 @@ BOOST_AUTO_TEST_CASE(SerializeNormalization)
     deserializedNetwork->Accept(verifier);
 }
 
-class PadLayerVerifier : public LayerVerifierBase
-{
-public:
-    PadLayerVerifier(const std::string& layerName,
-                     const std::vector<armnn::TensorInfo>& inputInfos,
-                     const std::vector<armnn::TensorInfo>& outputInfos,
-                     const armnn::PadDescriptor& descriptor)
-    : LayerVerifierBase(layerName, inputInfos, outputInfos), m_Descriptor(descriptor) {}
-
-    void VisitPadLayer(const armnn::IConnectableLayer* layer,
-                       const armnn::PadDescriptor& descriptor,
-                       const char* name) override
-    {
-        VerifyNameAndConnections(layer, name);
-        VerifyDescriptor(descriptor);
-    }
-
-private:
-    void VerifyDescriptor(const armnn::PadDescriptor& descriptor)
-    {
-        BOOST_TEST(descriptor.m_PadList == m_Descriptor.m_PadList);
-        BOOST_TEST(descriptor.m_PadValue == m_Descriptor.m_PadValue);
-    }
-
-    armnn::PadDescriptor m_Descriptor;
-};
+DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Pad)
 
 BOOST_AUTO_TEST_CASE(SerializePad)
 {
-
     const std::string layerName("pad");
     const armnn::TensorInfo inputTensorInfo = armnn::TensorInfo({1, 2, 3, 4}, armnn::DataType::Float32);
     const armnn::TensorInfo outputTensorInfo = armnn::TensorInfo({1, 3, 5, 7}, armnn::DataType::Float32);
@@ -2030,32 +1787,7 @@ BOOST_AUTO_TEST_CASE(CheckSerializePadBackwardCompatibility)
 
 BOOST_AUTO_TEST_CASE(SerializePermute)
 {
-    class PermuteLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        PermuteLayerVerifier(const std::string& layerName,
-                             const std::vector<armnn::TensorInfo>& inputInfos,
-                             const std::vector<armnn::TensorInfo>& outputInfos,
-                             const armnn::PermuteDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitPermuteLayer(const armnn::IConnectableLayer* layer,
-                               const armnn::PermuteDescriptor& descriptor,
-                               const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::PermuteDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_DimMappings.IsEqual(m_Descriptor.m_DimMappings));
-        }
-
-        armnn::PermuteDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Permute)
 
     const std::string layerName("permute");
     const armnn::TensorInfo inputTensorInfo({4, 3, 2, 1}, armnn::DataType::Float32);
@@ -2083,48 +1815,7 @@ BOOST_AUTO_TEST_CASE(SerializePermute)
 
 BOOST_AUTO_TEST_CASE(SerializePooling2d)
 {
-    class Pooling2dLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        Pooling2dLayerVerifier(const std::string& layerName,
-                               const std::vector<armnn::TensorInfo>& inputInfos,
-                               const std::vector<armnn::TensorInfo>& outputInfos,
-                               const armnn::Pooling2dDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitPooling2dLayer(const armnn::IConnectableLayer* layer,
-                                 const armnn::Pooling2dDescriptor& descriptor,
-                                 const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::Pooling2dDescriptor& descriptor)
-        {
-            BOOST_TEST(GetDataLayoutName(descriptor.m_DataLayout) == GetDataLayoutName(m_Descriptor.m_DataLayout));
-            BOOST_TEST(descriptor.m_PadLeft == m_Descriptor.m_PadLeft);
-            BOOST_TEST(descriptor.m_PadRight == m_Descriptor.m_PadRight);
-            BOOST_TEST(descriptor.m_PadTop == m_Descriptor.m_PadTop);
-            BOOST_TEST(descriptor.m_PadBottom == m_Descriptor.m_PadBottom);
-            BOOST_TEST(descriptor.m_PoolWidth == m_Descriptor.m_PoolWidth);
-            BOOST_TEST(descriptor.m_PoolHeight == m_Descriptor.m_PoolHeight);
-            BOOST_TEST(descriptor.m_StrideX == m_Descriptor.m_StrideX);
-            BOOST_TEST(descriptor.m_StrideY == m_Descriptor.m_StrideY);
-
-            BOOST_TEST(
-                static_cast<int>(descriptor.m_PaddingMethod) == static_cast<int>(m_Descriptor.m_PaddingMethod));
-            BOOST_TEST(
-                static_cast<int>(descriptor.m_PoolType) == static_cast<int>(m_Descriptor.m_PoolType));
-            BOOST_TEST(
-                static_cast<int>(descriptor.m_OutputShapeRounding) ==
-                static_cast<int>(m_Descriptor.m_OutputShapeRounding));
-        }
-
-        armnn::Pooling2dDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Pooling2d)
 
     const std::string layerName("pooling2d");
     const armnn::TensorInfo inputInfo({1, 2, 2, 1}, armnn::DataType::Float32);
@@ -2164,19 +1855,7 @@ BOOST_AUTO_TEST_CASE(SerializePooling2d)
 
 BOOST_AUTO_TEST_CASE(SerializeQuantize)
 {
-    class QuantizeLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        QuantizeLayerVerifier(const std::string& layerName,
-                             const std::vector<armnn::TensorInfo>& inputInfos,
-                             const std::vector<armnn::TensorInfo>& outputInfos)
-            : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitQuantizeLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Quantize)
 
     const std::string layerName("quantize");
     const armnn::TensorInfo info({ 1, 2, 2, 3 }, armnn::DataType::Float32);
@@ -2198,34 +1877,10 @@ BOOST_AUTO_TEST_CASE(SerializeQuantize)
     QuantizeLayerVerifier verifier(layerName, {info}, {info});
     deserializedNetwork->Accept(verifier);
 }
+
 BOOST_AUTO_TEST_CASE(SerializeReshape)
 {
-    class ReshapeLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        ReshapeLayerVerifier(const std::string& layerName,
-                             const std::vector<armnn::TensorInfo>& inputInfos,
-                             const std::vector<armnn::TensorInfo>& outputInfos,
-                             const armnn::ReshapeDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitReshapeLayer(const armnn::IConnectableLayer* layer,
-                               const armnn::ReshapeDescriptor& descriptor,
-                               const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::ReshapeDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_TargetShape == m_Descriptor.m_TargetShape);
-        }
-
-        armnn::ReshapeDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Reshape)
 
     const std::string layerName("reshape");
     const armnn::TensorInfo inputInfo({1, 9}, armnn::DataType::Float32);
@@ -2253,35 +1908,7 @@ BOOST_AUTO_TEST_CASE(SerializeReshape)
 
 BOOST_AUTO_TEST_CASE(SerializeResize)
 {
-    class ResizeLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        ResizeLayerVerifier(const std::string& layerName,
-                            const std::vector<armnn::TensorInfo>& inputInfos,
-                            const std::vector<armnn::TensorInfo>& outputInfos,
-                            const armnn::ResizeDescriptor& descriptor)
-                : LayerVerifierBase(layerName, inputInfos, outputInfos)
-                , m_Descriptor(descriptor) {}
-
-        void VisitResizeLayer(const armnn::IConnectableLayer* layer,
-                                      const armnn::ResizeDescriptor& descriptor,
-                                      const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::ResizeDescriptor& descriptor)
-        {
-            BOOST_CHECK(descriptor.m_DataLayout   == m_Descriptor.m_DataLayout);
-            BOOST_CHECK(descriptor.m_TargetWidth  == m_Descriptor.m_TargetWidth);
-            BOOST_CHECK(descriptor.m_TargetHeight == m_Descriptor.m_TargetHeight);
-            BOOST_CHECK(descriptor.m_Method       == m_Descriptor.m_Method);
-        }
-
-        armnn::ResizeDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Resize)
 
     const std::string layerName("resize");
     const armnn::TensorInfo inputInfo = armnn::TensorInfo({1, 3, 5, 5}, armnn::DataType::Float32);
@@ -2312,19 +1939,7 @@ BOOST_AUTO_TEST_CASE(SerializeResize)
 
 BOOST_AUTO_TEST_CASE(SerializeRsqrt)
 {
-    class RsqrtLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        RsqrtLayerVerifier(const std::string& layerName,
-                           const std::vector<armnn::TensorInfo>& inputInfos,
-                           const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitRsqrtLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Rsqrt)
 
     const std::string layerName("rsqrt");
     const armnn::TensorInfo tensorInfo({ 3, 1, 2 }, armnn::DataType::Float32);
@@ -2349,36 +1964,7 @@ BOOST_AUTO_TEST_CASE(SerializeRsqrt)
 
 BOOST_AUTO_TEST_CASE(SerializeSlice)
 {
-    class SliceLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        SliceLayerVerifier(const std::string& layerName,
-                           const std::vector<armnn::TensorInfo>& inputInfos,
-                           const std::vector<armnn::TensorInfo>& outputInfos,
-                           const armnn::SliceDescriptor& descriptor)
-            : LayerVerifierBase(layerName, inputInfos, outputInfos)
-            , m_Descriptor(descriptor) {}
-
-        void VisitSliceLayer(const armnn::IConnectableLayer* layer,
-                             const armnn::SliceDescriptor& descriptor,
-                             const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::SliceDescriptor& descriptor)
-        {
-            BOOST_CHECK_EQUAL_COLLECTIONS(descriptor.m_Begin.begin(), descriptor.m_Begin.end(),
-                                          m_Descriptor.m_Begin.begin(), m_Descriptor.m_Begin.end());
-
-            BOOST_CHECK_EQUAL_COLLECTIONS(descriptor.m_Size.begin(), descriptor.m_Size.end(),
-                                          m_Descriptor.m_Size.begin(), m_Descriptor.m_Size.end());
-        }
-
-        armnn::SliceDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Slice)
 
     const std::string layerName{"slice"};
 
@@ -2408,32 +1994,7 @@ BOOST_AUTO_TEST_CASE(SerializeSlice)
 
 BOOST_AUTO_TEST_CASE(SerializeSoftmax)
 {
-    class SoftmaxLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        SoftmaxLayerVerifier(const std::string& layerName,
-                             const std::vector<armnn::TensorInfo>& inputInfos,
-                             const std::vector<armnn::TensorInfo>& outputInfos,
-                             const armnn::SoftmaxDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitSoftmaxLayer(const armnn::IConnectableLayer* layer,
-                               const armnn::SoftmaxDescriptor& descriptor,
-                               const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::SoftmaxDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_Beta == m_Descriptor.m_Beta);
-        }
-
-        armnn::SoftmaxDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Softmax)
 
     const std::string layerName("softmax");
     const armnn::TensorInfo info({1, 10}, armnn::DataType::Float32);
@@ -2461,34 +2022,7 @@ BOOST_AUTO_TEST_CASE(SerializeSoftmax)
 
 BOOST_AUTO_TEST_CASE(SerializeSpaceToBatchNd)
 {
-    class SpaceToBatchNdLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        SpaceToBatchNdLayerVerifier(const std::string& layerName,
-                                    const std::vector<armnn::TensorInfo>& inputInfos,
-                                    const std::vector<armnn::TensorInfo>& outputInfos,
-                                    const armnn::SpaceToBatchNdDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitSpaceToBatchNdLayer(const armnn::IConnectableLayer* layer,
-                                      const armnn::SpaceToBatchNdDescriptor& descriptor,
-                                      const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::SpaceToBatchNdDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_PadList == m_Descriptor.m_PadList);
-            BOOST_TEST(descriptor.m_BlockShape == m_Descriptor.m_BlockShape);
-            BOOST_TEST(GetDataLayoutName(descriptor.m_DataLayout) == GetDataLayoutName(m_Descriptor.m_DataLayout));
-        }
-
-        armnn::SpaceToBatchNdDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(SpaceToBatchNd)
 
     const std::string layerName("spaceToBatchNd");
     const armnn::TensorInfo inputInfo({2, 1, 2, 4}, armnn::DataType::Float32);
@@ -2519,33 +2053,7 @@ BOOST_AUTO_TEST_CASE(SerializeSpaceToBatchNd)
 
 BOOST_AUTO_TEST_CASE(SerializeSpaceToDepth)
 {
-    class SpaceToDepthLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        SpaceToDepthLayerVerifier(const std::string& layerName,
-                                  const std::vector<armnn::TensorInfo>& inputInfos,
-                                  const std::vector<armnn::TensorInfo>& outputInfos,
-                                  const armnn::SpaceToDepthDescriptor& descriptor)
-            : LayerVerifierBase(layerName, inputInfos, outputInfos)
-            , m_Descriptor(descriptor) {}
-
-        void VisitSpaceToDepthLayer(const armnn::IConnectableLayer* layer,
-                                    const armnn::SpaceToDepthDescriptor& descriptor,
-                                    const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::SpaceToDepthDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_BlockSize == m_Descriptor.m_BlockSize);
-            BOOST_TEST(GetDataLayoutName(descriptor.m_DataLayout) == GetDataLayoutName(m_Descriptor.m_DataLayout));
-        }
-
-        armnn::SpaceToDepthDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(SpaceToDepth)
 
     const std::string layerName("spaceToDepth");
 
@@ -2576,42 +2084,7 @@ BOOST_AUTO_TEST_CASE(SerializeSpaceToDepth)
 
 BOOST_AUTO_TEST_CASE(SerializeSplitter)
 {
-    class SplitterLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        SplitterLayerVerifier(const std::string& layerName,
-                              const std::vector<armnn::TensorInfo>& inputInfos,
-                              const std::vector<armnn::TensorInfo>& outputInfos,
-                              const armnn::ViewsDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitSplitterLayer(const armnn::IConnectableLayer* layer,
-                                const armnn::ViewsDescriptor& descriptor,
-                                const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::ViewsDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.GetNumViews() == m_Descriptor.GetNumViews());
-            BOOST_TEST(descriptor.GetNumDimensions() == m_Descriptor.GetNumDimensions());
-
-            for (uint32_t i = 0; i < descriptor.GetNumViews(); i++)
-            {
-                for (uint32_t j = 0; j < descriptor.GetNumDimensions(); j++)
-                {
-                    BOOST_TEST(descriptor.GetViewOrigin(i)[j] == m_Descriptor.GetViewOrigin(i)[j]);
-                    BOOST_TEST(descriptor.GetViewSizes(i)[j] == m_Descriptor.GetViewSizes(i)[j]);
-                }
-            }
-        }
-
-        armnn::ViewsDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Splitter)
 
     const unsigned int numViews = 3;
     const unsigned int numDimensions = 4;
@@ -2666,34 +2139,7 @@ BOOST_AUTO_TEST_CASE(SerializeSplitter)
 
 BOOST_AUTO_TEST_CASE(SerializeStack)
 {
-    class StackLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        StackLayerVerifier(const std::string& layerName,
-                           const std::vector<armnn::TensorInfo>& inputInfos,
-                           const std::vector<armnn::TensorInfo>& outputInfos,
-                           const armnn::StackDescriptor& descriptor)
-            : LayerVerifierBase(layerName, inputInfos, outputInfos)
-            , m_Descriptor(descriptor) {}
-
-        void VisitStackLayer(const armnn::IConnectableLayer* layer,
-                             const armnn::StackDescriptor& descriptor,
-                             const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::StackDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_Axis == m_Descriptor.m_Axis);
-            BOOST_TEST(descriptor.m_InputShape == m_Descriptor.m_InputShape);
-            BOOST_TEST(descriptor.m_NumInputs == m_Descriptor.m_NumInputs);
-        }
-
-        armnn::StackDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(Stack)
 
     const std::string layerName("stack");
 
@@ -2725,39 +2171,7 @@ BOOST_AUTO_TEST_CASE(SerializeStack)
 
 BOOST_AUTO_TEST_CASE(SerializeStridedSlice)
 {
-    class StridedSliceLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        StridedSliceLayerVerifier(const std::string& layerName,
-                                  const std::vector<armnn::TensorInfo>& inputInfos,
-                                  const std::vector<armnn::TensorInfo>& outputInfos,
-                                  const armnn::StridedSliceDescriptor& descriptor)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos)
-        , m_Descriptor(descriptor) {}
-
-        void VisitStridedSliceLayer(const armnn::IConnectableLayer* layer,
-                                    const armnn::StridedSliceDescriptor& descriptor,
-                                    const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-            VerifyDescriptor(descriptor);
-        }
-
-    private:
-        void VerifyDescriptor(const armnn::StridedSliceDescriptor& descriptor)
-        {
-            BOOST_TEST(descriptor.m_Begin == m_Descriptor.m_Begin);
-            BOOST_TEST(descriptor.m_End == m_Descriptor.m_End);
-            BOOST_TEST(descriptor.m_Stride == m_Descriptor.m_Stride);
-            BOOST_TEST(descriptor.m_BeginMask == m_Descriptor.m_BeginMask);
-            BOOST_TEST(descriptor.m_EndMask == m_Descriptor.m_EndMask);
-            BOOST_TEST(descriptor.m_ShrinkAxisMask == m_Descriptor.m_ShrinkAxisMask);
-            BOOST_TEST(descriptor.m_EllipsisMask == m_Descriptor.m_EllipsisMask);
-            BOOST_TEST(descriptor.m_NewAxisMask == m_Descriptor.m_NewAxisMask);
-            BOOST_TEST(GetDataLayoutName(descriptor.m_DataLayout) == GetDataLayoutName(m_Descriptor.m_DataLayout));
-        }
-        armnn::StridedSliceDescriptor m_Descriptor;
-    };
+    DECLARE_LAYER_VERIFIER_CLASS_WITH_DESCRIPTOR(StridedSlice)
 
     const std::string layerName("stridedSlice");
     const armnn::TensorInfo inputInfo = armnn::TensorInfo({3, 2, 3, 1}, armnn::DataType::Float32);
@@ -2788,19 +2202,7 @@ BOOST_AUTO_TEST_CASE(SerializeStridedSlice)
 
 BOOST_AUTO_TEST_CASE(SerializeSubtraction)
 {
-    class SubtractionLayerVerifier : public LayerVerifierBase
-    {
-    public:
-        SubtractionLayerVerifier(const std::string& layerName,
-                                 const std::vector<armnn::TensorInfo>& inputInfos,
-                                 const std::vector<armnn::TensorInfo>& outputInfos)
-        : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
-
-        void VisitSubtractionLayer(const armnn::IConnectableLayer* layer, const char* name) override
-        {
-            VerifyNameAndConnections(layer, name);
-        }
-    };
+    DECLARE_LAYER_VERIFIER_CLASS(Subtraction)
 
     const std::string layerName("subtraction");
     const armnn::TensorInfo info({ 1, 4 }, armnn::DataType::Float32);
@@ -2832,8 +2234,8 @@ BOOST_AUTO_TEST_CASE(SerializeSwitch)
     {
     public:
         SwitchLayerVerifier(const std::string& layerName,
-                                 const std::vector<armnn::TensorInfo>& inputInfos,
-                                 const std::vector<armnn::TensorInfo>& outputInfos)
+                            const std::vector<armnn::TensorInfo>& inputInfos,
+                            const std::vector<armnn::TensorInfo>& outputInfos)
             : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
 
         void VisitSwitchLayer(const armnn::IConnectableLayer* layer, const char* name) override
@@ -2878,23 +2280,23 @@ BOOST_AUTO_TEST_CASE(SerializeSwitch)
 
 BOOST_AUTO_TEST_CASE(SerializeTransposeConvolution2d)
 {
-    class TransposeConvolution2dLayerVerifier : public LayerVerifierBase
+    using Descriptor = armnn::TransposeConvolution2dDescriptor;
+    class TransposeConvolution2dLayerVerifier : public LayerVerifierBaseWithDescriptor<Descriptor>
     {
     public:
         TransposeConvolution2dLayerVerifier(const std::string& layerName,
                                             const std::vector<armnn::TensorInfo>& inputInfos,
                                             const std::vector<armnn::TensorInfo>& outputInfos,
-                                            const armnn::TransposeConvolution2dDescriptor& descriptor,
+                                            const Descriptor& descriptor,
                                             const armnn::ConstTensor& weights,
-                                            const armnn::Optional<armnn::ConstTensor>& biases) :
-            LayerVerifierBase(layerName, inputInfos, outputInfos),
-            m_Descriptor(descriptor),
-            m_Weights(weights),
-            m_Biases(biases)
+                                            const armnn::Optional<armnn::ConstTensor>& biases)
+            : LayerVerifierBaseWithDescriptor<Descriptor>(layerName, inputInfos, outputInfos, descriptor)
+            , m_Weights(weights)
+            , m_Biases(biases)
         {}
 
         void VisitTransposeConvolution2dLayer(const armnn::IConnectableLayer* layer,
-                                              const armnn::TransposeConvolution2dDescriptor& descriptor,
+                                              const Descriptor& descriptor,
                                               const armnn::ConstTensor& weights,
                                               const armnn::Optional<armnn::ConstTensor>& biases,
                                               const char* name) override
@@ -2906,9 +2308,7 @@ BOOST_AUTO_TEST_CASE(SerializeTransposeConvolution2d)
             CompareConstTensor(weights, m_Weights);
 
             // check biases
-            BOOST_CHECK(biases.has_value()   == descriptor.m_BiasEnabled);
-            BOOST_CHECK(m_Biases.has_value() == m_Descriptor.m_BiasEnabled);
-
+            BOOST_CHECK(biases.has_value() == descriptor.m_BiasEnabled);
             BOOST_CHECK(biases.has_value() == m_Biases.has_value());
 
             if (biases.has_value() && m_Biases.has_value())
@@ -2918,19 +2318,6 @@ BOOST_AUTO_TEST_CASE(SerializeTransposeConvolution2d)
         }
 
     private:
-        void VerifyDescriptor(const armnn::TransposeConvolution2dDescriptor& descriptor)
-        {
-            BOOST_CHECK(descriptor.m_PadLeft     == m_Descriptor.m_PadLeft);
-            BOOST_CHECK(descriptor.m_PadRight    == m_Descriptor.m_PadRight);
-            BOOST_CHECK(descriptor.m_PadTop      == m_Descriptor.m_PadTop);
-            BOOST_CHECK(descriptor.m_PadBottom   == m_Descriptor.m_PadBottom);
-            BOOST_CHECK(descriptor.m_StrideX     == m_Descriptor.m_StrideX);
-            BOOST_CHECK(descriptor.m_StrideY     == m_Descriptor.m_StrideY);
-            BOOST_CHECK(descriptor.m_BiasEnabled == m_Descriptor.m_BiasEnabled);
-            BOOST_CHECK(descriptor.m_DataLayout  == m_Descriptor.m_DataLayout);
-        }
-
-        armnn::TransposeConvolution2dDescriptor m_Descriptor;
         armnn::ConstTensor                      m_Weights;
         armnn::Optional<armnn::ConstTensor>     m_Biases;
     };
@@ -2997,7 +2384,6 @@ BOOST_AUTO_TEST_CASE(SerializeDeserializeNonLinearNetwork)
                                 const char* name) override
         {
             VerifyNameAndConnections(layer, name);
-
             CompareConstTensor(input, m_LayerInput);
         }
 
@@ -3034,17 +2420,17 @@ BOOST_AUTO_TEST_CASE(SerializeDeserializeNonLinearNetwork)
     deserializedNetwork->Accept(verifier);
 }
 
-class VerifyLstmLayer : public LayerVerifierBase
+class VerifyLstmLayer : public LayerVerifierBaseWithDescriptor<armnn::LstmDescriptor>
 {
 public:
     VerifyLstmLayer(const std::string& layerName,
                     const std::vector<armnn::TensorInfo>& inputInfos,
                     const std::vector<armnn::TensorInfo>& outputInfos,
                     const armnn::LstmDescriptor& descriptor,
-                    const armnn::LstmInputParams& inputParams) :
-         LayerVerifierBase(layerName, inputInfos, outputInfos), m_Descriptor(descriptor), m_InputParams(inputParams)
-    {
-    }
+                    const armnn::LstmInputParams& inputParams)
+        : LayerVerifierBaseWithDescriptor<armnn::LstmDescriptor>(layerName, inputInfos, outputInfos, descriptor)
+        , m_InputParams(inputParams) {}
+
     void VisitLstmLayer(const armnn::IConnectableLayer* layer,
                         const armnn::LstmDescriptor& descriptor,
                         const armnn::LstmInputParams& params,
@@ -3054,17 +2440,8 @@ public:
         VerifyDescriptor(descriptor);
         VerifyInputParameters(params);
     }
+
 protected:
-    void VerifyDescriptor(const armnn::LstmDescriptor& descriptor)
-    {
-        BOOST_TEST(m_Descriptor.m_ActivationFunc == descriptor.m_ActivationFunc);
-        BOOST_TEST(m_Descriptor.m_ClippingThresCell == descriptor.m_ClippingThresCell);
-        BOOST_TEST(m_Descriptor.m_ClippingThresProj == descriptor.m_ClippingThresProj);
-        BOOST_TEST(m_Descriptor.m_CifgEnabled == descriptor.m_CifgEnabled);
-        BOOST_TEST(m_Descriptor.m_PeepholeEnabled = descriptor.m_PeepholeEnabled);
-        BOOST_TEST(m_Descriptor.m_ProjectionEnabled == descriptor.m_ProjectionEnabled);
-        BOOST_TEST(m_Descriptor.m_LayerNormEnabled == descriptor.m_LayerNormEnabled);
-    }
     void VerifyInputParameters(const armnn::LstmInputParams& params)
     {
         VerifyConstTensors(
@@ -3110,8 +2487,8 @@ protected:
         VerifyConstTensors(
             "m_OutputLayerNormWeights", m_InputParams.m_OutputLayerNormWeights, params.m_OutputLayerNormWeights);
     }
+
 private:
-    armnn::LstmDescriptor m_Descriptor;
     armnn::LstmInputParams m_InputParams;
 };
 
@@ -4213,7 +3590,6 @@ BOOST_AUTO_TEST_CASE(EnsureLstmLayersBackwardCompatibility)
             params);
     deserializedNetwork->Accept(checker);
 }
-
 class VerifyQuantizedLstmLayer : public LayerVerifierBase
 {
 
@@ -4221,10 +3597,8 @@ public:
     VerifyQuantizedLstmLayer(const std::string& layerName,
                              const std::vector<armnn::TensorInfo>& inputInfos,
                              const std::vector<armnn::TensorInfo>& outputInfos,
-                             const armnn::QuantizedLstmInputParams& inputParams) :
-            LayerVerifierBase(layerName, inputInfos, outputInfos), m_InputParams(inputParams)
-    {
-    }
+                             const armnn::QuantizedLstmInputParams& inputParams)
+        : LayerVerifierBase(layerName, inputInfos, outputInfos), m_InputParams(inputParams) {}
 
     void VisitQuantizedLstmLayer(const armnn::IConnectableLayer* layer,
                                  const armnn::QuantizedLstmInputParams& params,