IVGCVSW-2551 Add Descriptor and name only unit tests for Visitor

 * Add concrete subclasses for layers taking descriptor as argument
 * Add unit test cases for all layers

Change-Id: Ie0135b34a5a41e5ce654b7c3186eccea392ab919
Signed-off-by: FrancisMurtagh <francis.murtagh@arm.com>

3 files changed, 1105 insertions, 0 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 282b46d874..bf885a2125 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -398,6 +398,8 @@ if(BUILD_UNIT_TESTS)
         src/armnn/test/TestLayerVisitor.hpp
         src/armnn/test/TestNameOnlyLayerVisitor.cpp
         src/armnn/test/TestNameOnlyLayerVisitor.hpp
+        src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp
+        src/armnn/test/TestNameAndDescriptorLayerVisitor.cpp
         src/armnn/test/UnitTests.cpp
         src/armnn/test/UnitTests.hpp
         src/armnn/test/UtilsTests.cpp
diff --git a/src/armnn/test/TestNameAndDescriptorLayerVisitor.cpp b/src/armnn/test/TestNameAndDescriptorLayerVisitor.cpp
new file mode 100644
index 0000000000..dbadb75a09
--- /dev/null
+++ b/src/armnn/test/TestNameAndDescriptorLayerVisitor.cpp
@@ -0,0 +1,428 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#include "TestNameAndDescriptorLayerVisitor.hpp"
+#include "Network.hpp"
+
+namespace armnn
+{
+
+void Set2dDataValues(SplitterDescriptor descriptor, u_int32_t value)
+{
+    for (unsigned int i = 0; i < descriptor.GetNumViews(); ++i)
+    {
+        for (unsigned int j = 0; j < descriptor.GetNumDimensions(); ++j)
+        {
+            descriptor.SetViewOriginCoord(i, j, value);
+            descriptor.SetViewSize(i, j, value);
+        }
+    }
+}
+
+void Set2dDataValues(MergerDescriptor descriptor, u_int32_t value)
+{
+    for (unsigned int i = 0; i < descriptor.GetNumViews(); ++i)
+    {
+        for (unsigned int j = 0; j < descriptor.GetNumDimensions(); ++j)
+        {
+            descriptor.SetViewOriginCoord(i, j, value);
+        }
+    }
+}
+
+BOOST_AUTO_TEST_SUITE(TestNameAndDescriptorLayerVisitor)
+
+BOOST_AUTO_TEST_CASE(CheckPermuteLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "PermuteLayer";
+    PermuteDescriptor descriptor({0, 1, 2, 3});
+    TestPermuteLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddPermuteLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckPermuteLayerVisitorNameNullAndDescriptor)
+{
+    PermuteDescriptor descriptor({0, 1, 2, 3});
+    TestPermuteLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddPermuteLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckBatchToSpaceNdLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "BatchToSpaceNdLayer";
+    BatchToSpaceNdDescriptor descriptor({1, 1}, {{0, 0}, {0, 0}});
+    descriptor.m_DataLayout = armnn::DataLayout::NHWC;
+    TestBatchToSpaceNdLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddBatchToSpaceNdLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckBatchToSpaceNdLayerVisitorNameNullAndDescriptor)
+{
+    BatchToSpaceNdDescriptor descriptor({1, 1}, {{0, 0}, {0, 0}});
+    descriptor.m_DataLayout = armnn::DataLayout::NHWC;
+    TestBatchToSpaceNdLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddBatchToSpaceNdLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckPooling2dLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "Pooling2dLayer";
+    Pooling2dDescriptor descriptor;
+    descriptor.m_PoolType            = PoolingAlgorithm::Max;
+    descriptor.m_PadLeft             = 1;
+    descriptor.m_PadRight            = 1;
+    descriptor.m_PadTop              = 1;
+    descriptor.m_PadBottom           = 1;
+    descriptor.m_PoolWidth           = 1;
+    descriptor.m_PoolHeight          = 1;
+    descriptor.m_StrideX             = 1;
+    descriptor.m_StrideY             = 1;
+    descriptor.m_OutputShapeRounding = OutputShapeRounding::Ceiling;
+    descriptor.m_PaddingMethod       = PaddingMethod::IgnoreValue;
+    descriptor.m_DataLayout          = DataLayout::NHWC;
+    TestPooling2dLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddPooling2dLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckPooling2dLayerVisitorNameNullAndDescriptor)
+{
+    Pooling2dDescriptor descriptor;
+    descriptor.m_PoolType            = PoolingAlgorithm::Max;
+    descriptor.m_PadLeft             = 1;
+    descriptor.m_PadRight            = 1;
+    descriptor.m_PadTop              = 1;
+    descriptor.m_PadBottom           = 1;
+    descriptor.m_PoolWidth           = 1;
+    descriptor.m_PoolHeight          = 1;
+    descriptor.m_StrideX             = 1;
+    descriptor.m_StrideY             = 1;
+    descriptor.m_OutputShapeRounding = OutputShapeRounding::Ceiling;
+    descriptor.m_PaddingMethod       = PaddingMethod::IgnoreValue;
+    descriptor.m_DataLayout          = DataLayout::NHWC;
+    TestPooling2dLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddPooling2dLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckActivationLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "ActivationLayer";
+    ActivationDescriptor descriptor;
+    descriptor.m_Function = ActivationFunction::Linear;
+    descriptor.m_A = 2;
+    descriptor.m_B = 2;
+    TestActivationLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddActivationLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckActivationLayerVisitorNameNullAndDescriptor)
+{
+    ActivationDescriptor descriptor;
+    descriptor.m_Function = ActivationFunction::Linear;
+    descriptor.m_A = 2;
+    descriptor.m_B = 2;
+    TestActivationLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddActivationLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckNormalizationLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "NormalizationLayer";
+    NormalizationDescriptor descriptor;
+    descriptor.m_NormChannelType = NormalizationAlgorithmChannel::Within;
+    descriptor.m_NormMethodType  = NormalizationAlgorithmMethod::LocalContrast;
+    descriptor.m_NormSize        = 1;
+    descriptor.m_Alpha           = 1;
+    descriptor.m_Beta            = 1;
+    descriptor.m_K               = 1;
+    descriptor.m_DataLayout      = DataLayout::NHWC;
+    TestNormalizationLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddNormalizationLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckNormalizationLayerVisitorNameNullAndDescriptor)
+{
+    NormalizationDescriptor descriptor;
+    descriptor.m_NormChannelType = NormalizationAlgorithmChannel::Within;
+    descriptor.m_NormMethodType  = NormalizationAlgorithmMethod::LocalContrast;
+    descriptor.m_NormSize        = 1;
+    descriptor.m_Alpha           = 1;
+    descriptor.m_Beta            = 1;
+    descriptor.m_K               = 1;
+    descriptor.m_DataLayout      = DataLayout::NHWC;
+    TestNormalizationLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddNormalizationLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckSoftmaxLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "SoftmaxLayer";
+    SoftmaxDescriptor descriptor;
+    descriptor.m_Beta = 2;
+    TestSoftmaxLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddSoftmaxLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckSoftmaxLayerVisitorNameNullAndDescriptor)
+{
+    SoftmaxDescriptor descriptor;
+    descriptor.m_Beta = 2;
+    TestSoftmaxLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddSoftmaxLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckSplitterLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "SplitterLayer";
+    SplitterDescriptor descriptor(2, 2);
+    Set2dDataValues(descriptor, 1);
+    TestSplitterLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddSplitterLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckSplitterLayerVisitorNameNullAndDescriptor)
+{
+    SplitterDescriptor descriptor(2, 2);
+    Set2dDataValues(descriptor, 1);
+    TestSplitterLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddSplitterLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckMergerLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "MergerLayer";
+    MergerDescriptor descriptor(2, 2);
+    Set2dDataValues(descriptor, 1);
+    descriptor.SetConcatAxis(1);
+    TestMergerLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddMergerLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckMergerLayerVisitorNameNullAndDescriptor)
+{
+    MergerDescriptor descriptor(2, 2);
+    Set2dDataValues(descriptor, 1);
+    descriptor.SetConcatAxis(1);
+    TestMergerLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddMergerLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckResizeBilinearLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "ResizeBilinearLayer";
+    ResizeBilinearDescriptor descriptor;
+    descriptor.m_TargetHeight = 1;
+    descriptor.m_TargetWidth  = 1;
+    descriptor.m_DataLayout   = DataLayout::NHWC;
+    TestResizeBilinearLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddResizeBilinearLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckResizeBilinearLayerVisitorNameNullAndDescriptor)
+{
+    ResizeBilinearDescriptor descriptor;
+    descriptor.m_TargetHeight = 1;
+    descriptor.m_TargetWidth  = 1;
+    descriptor.m_DataLayout   = DataLayout::NHWC;
+    TestResizeBilinearLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddResizeBilinearLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckL2NormalizationLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "L2NormalizationLayer";
+    L2NormalizationDescriptor descriptor;
+    descriptor.m_DataLayout = DataLayout::NHWC;
+    TestL2NormalizationLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddL2NormalizationLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckL2NormalizationLayerVisitorNameNullAndDescriptor)
+{
+    L2NormalizationDescriptor descriptor;
+    descriptor.m_DataLayout = DataLayout::NHWC;
+    TestL2NormalizationLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddL2NormalizationLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckReshapeLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "ReshapeLayer";
+    ReshapeDescriptor descriptor({1, 2, 3, 4});
+    TestReshapeLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddReshapeLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckReshapeLayerVisitorNameNullAndDescriptor)
+{
+    ReshapeDescriptor descriptor({1, 2, 3, 4});
+    TestReshapeLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddReshapeLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckSpaceToBatchNdLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "SpaceToBatchNdLayer";
+    SpaceToBatchNdDescriptor descriptor({2, 2}, {{1, 1}, {1, 1}});
+    TestSpaceToBatchNdLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddSpaceToBatchNdLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckSpaceToBatchNdLayerVisitorNameNullAndDescriptor)
+{
+    SpaceToBatchNdDescriptor descriptor({2, 2}, {{1, 1}, {1, 1}});
+    TestSpaceToBatchNdLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddSpaceToBatchNdLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+
+BOOST_AUTO_TEST_CASE(CheckMeanLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "MeanLayer";
+    MeanDescriptor descriptor({1, 2}, false);
+    TestMeanLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddMeanLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckMeanLayerVisitorNameNullAndDescriptor)
+{
+    MeanDescriptor descriptor({1, 2}, false);
+    TestMeanLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddMeanLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckPadLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "PadLayer";
+    PadDescriptor descriptor({{1, 2}, {3, 4}});
+    TestPadLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddPadLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckPadLayerVisitorNameNullAndDescriptor)
+{
+    PadDescriptor descriptor({{1, 2}, {3, 4}});
+    TestPadLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddPadLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckStridedSliceLayerVisitorNameAndDescriptor)
+{
+    const char* layerName = "StridedSliceLayer";
+    StridedSliceDescriptor descriptor({1, 2}, {3, 4}, {3, 4});
+    descriptor.m_BeginMask      = 1;
+    descriptor.m_EndMask        = 1;
+    descriptor.m_ShrinkAxisMask = 1;
+    descriptor.m_EllipsisMask   = 1;
+    descriptor.m_NewAxisMask    = 1;
+    descriptor.m_DataLayout     = DataLayout::NHWC;
+    TestStridedSliceLayerVisitor visitor(descriptor, layerName);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddStridedSliceLayer(descriptor, layerName);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_CASE(CheckStridedSliceLayerVisitorNameNullAndDescriptor)
+{
+    StridedSliceDescriptor descriptor({1, 2}, {3, 4}, {3, 4});
+    descriptor.m_BeginMask      = 1;
+    descriptor.m_EndMask        = 1;
+    descriptor.m_ShrinkAxisMask = 1;
+    descriptor.m_EllipsisMask   = 1;
+    descriptor.m_NewAxisMask    = 1;
+    descriptor.m_DataLayout     = DataLayout::NHWC;
+    TestStridedSliceLayerVisitor visitor(descriptor);
+    Network net;
+
+    IConnectableLayer *const layer = net.AddStridedSliceLayer(descriptor);
+    layer->Accept(visitor);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} //namespace armnn
\ No newline at end of file
diff --git a/src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp b/src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp
new file mode 100644
index 0000000000..bf23332fb8
--- /dev/null
+++ b/src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp
@@ -0,0 +1,675 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include <armnn/ArmNN.hpp>
+#include "TestLayerVisitor.hpp"
+#include <boost/test/unit_test.hpp>
+
+namespace armnn
+{
+
+// Concrete TestLayerVisitor subclasses for layers taking Descriptor argument with overridden VisitLayer methods
+class TestPermuteLayerVisitor : public TestLayerVisitor
+{
+private:
+    const PermuteDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestPermuteLayerVisitor(const PermuteDescriptor& permuteDescriptor, const char* name = nullptr)
+        : TestLayerVisitor(name)
+        , m_VisitorDescriptor(permuteDescriptor.m_DimMappings)
+    {};
+
+    void CheckDescriptor(const PermuteDescriptor& permuteDescriptor)
+    {
+        if (permuteDescriptor.m_DimMappings.GetSize() == m_VisitorDescriptor.m_DimMappings.GetSize())
+        {
+            for (unsigned int i = 0; i < permuteDescriptor.m_DimMappings.GetSize(); ++i)
+            {
+                BOOST_CHECK_EQUAL(permuteDescriptor.m_DimMappings[i], m_VisitorDescriptor.m_DimMappings[i]);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for batchToSpaceNdDescriptor m_DimMappings.");
+        }
+    };
+
+    void VisitPermuteLayer(const IConnectableLayer* layer,
+                           const PermuteDescriptor& permuteDescriptor,
+                           const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(permuteDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestBatchToSpaceNdLayerVisitor : public TestLayerVisitor
+{
+private:
+    BatchToSpaceNdDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestBatchToSpaceNdLayerVisitor(const BatchToSpaceNdDescriptor& batchToSpaceNdDescriptor,
+                                            const char* name = nullptr)
+            : TestLayerVisitor(name)
+            , m_VisitorDescriptor(batchToSpaceNdDescriptor.m_BlockShape, batchToSpaceNdDescriptor.m_Crops)
+    {
+        m_VisitorDescriptor.m_DataLayout = batchToSpaceNdDescriptor.m_DataLayout;
+    };
+
+    void CheckDescriptor(const BatchToSpaceNdDescriptor& batchToSpaceNdDescriptor)
+    {
+        if (batchToSpaceNdDescriptor.m_BlockShape.size() == m_VisitorDescriptor.m_BlockShape.size())
+        {
+            for (unsigned int i = 0; i < batchToSpaceNdDescriptor.m_BlockShape.size(); ++i)
+            {
+                BOOST_CHECK_EQUAL(batchToSpaceNdDescriptor.m_BlockShape[i], m_VisitorDescriptor.m_BlockShape[i]);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for batchToSpaceNdDescriptor m_BlockShape.");
+        }
+
+        if (batchToSpaceNdDescriptor.m_Crops.size() == m_VisitorDescriptor.m_Crops.size())
+        {
+            for (unsigned int i = 0; i < batchToSpaceNdDescriptor.m_Crops.size(); ++i)
+            {
+                BOOST_CHECK_EQUAL(batchToSpaceNdDescriptor.m_Crops[i].first, m_VisitorDescriptor.m_Crops[i].first);
+                BOOST_CHECK_EQUAL(batchToSpaceNdDescriptor.m_Crops[i].second, m_VisitorDescriptor.m_Crops[i].second);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for batchToSpaceNdDescriptor m_Crops.");
+        }
+
+        BOOST_CHECK(batchToSpaceNdDescriptor.m_DataLayout == m_VisitorDescriptor.m_DataLayout);
+    }
+
+    void VisitBatchToSpaceNdLayer(const IConnectableLayer* layer,
+                                  const BatchToSpaceNdDescriptor& batchToSpaceNdDescriptor,
+                                  const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(batchToSpaceNdDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestPooling2dLayerVisitor : public TestLayerVisitor
+{
+private:
+    Pooling2dDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestPooling2dLayerVisitor(const Pooling2dDescriptor& pooling2dDescriptor, const char* name = nullptr)
+        : TestLayerVisitor(name)
+    {
+        m_VisitorDescriptor.m_PoolType            = pooling2dDescriptor.m_PoolType;
+        m_VisitorDescriptor.m_PadLeft             = pooling2dDescriptor.m_PadLeft;
+        m_VisitorDescriptor.m_PadRight            = pooling2dDescriptor.m_PadRight;
+        m_VisitorDescriptor.m_PadTop              = pooling2dDescriptor.m_PadTop;
+        m_VisitorDescriptor.m_PadBottom           = pooling2dDescriptor.m_PadBottom;
+        m_VisitorDescriptor.m_PoolWidth           = pooling2dDescriptor.m_PoolWidth;
+        m_VisitorDescriptor.m_PoolHeight          = pooling2dDescriptor.m_PoolHeight;
+        m_VisitorDescriptor.m_StrideX             = pooling2dDescriptor.m_StrideX;
+        m_VisitorDescriptor.m_StrideY             = pooling2dDescriptor.m_StrideY;
+        m_VisitorDescriptor.m_OutputShapeRounding = pooling2dDescriptor.m_OutputShapeRounding;
+        m_VisitorDescriptor.m_PaddingMethod       = pooling2dDescriptor.m_PaddingMethod;
+        m_VisitorDescriptor.m_DataLayout          = pooling2dDescriptor.m_DataLayout;
+    };
+
+    void CheckDescriptor(const Pooling2dDescriptor& pooling2dDescriptor)
+    {
+        BOOST_CHECK(pooling2dDescriptor.m_PoolType == m_VisitorDescriptor.m_PoolType);
+        BOOST_CHECK_EQUAL(pooling2dDescriptor.m_PadLeft, m_VisitorDescriptor.m_PadLeft);
+        BOOST_CHECK_EQUAL(pooling2dDescriptor.m_PadRight, m_VisitorDescriptor.m_PadRight);
+        BOOST_CHECK_EQUAL(pooling2dDescriptor.m_PadTop, m_VisitorDescriptor.m_PadTop);
+        BOOST_CHECK_EQUAL(pooling2dDescriptor.m_PadBottom, m_VisitorDescriptor.m_PadBottom);
+        BOOST_CHECK_EQUAL(pooling2dDescriptor.m_PoolWidth, m_VisitorDescriptor.m_PoolWidth);
+        BOOST_CHECK_EQUAL(pooling2dDescriptor.m_PoolHeight, m_VisitorDescriptor.m_PoolHeight);
+        BOOST_CHECK_EQUAL(pooling2dDescriptor.m_StrideX, m_VisitorDescriptor.m_StrideX);
+        BOOST_CHECK_EQUAL(pooling2dDescriptor.m_StrideY, m_VisitorDescriptor.m_StrideY);
+        BOOST_CHECK(pooling2dDescriptor.m_OutputShapeRounding == m_VisitorDescriptor.m_OutputShapeRounding);
+        BOOST_CHECK(pooling2dDescriptor.m_PaddingMethod == m_VisitorDescriptor.m_PaddingMethod);
+        BOOST_CHECK(pooling2dDescriptor.m_DataLayout == m_VisitorDescriptor.m_DataLayout);
+    }
+
+    void VisitPooling2dLayer(const IConnectableLayer* layer,
+                             const Pooling2dDescriptor& pooling2dDescriptor,
+                             const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(pooling2dDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestActivationLayerVisitor : public TestLayerVisitor
+{
+private:
+    ActivationDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestActivationLayerVisitor(const ActivationDescriptor& activationDescriptor, const char* name = nullptr)
+        : TestLayerVisitor(name)
+    {
+        m_VisitorDescriptor.m_Function = activationDescriptor.m_Function;
+        m_VisitorDescriptor.m_A = activationDescriptor.m_A;
+        m_VisitorDescriptor.m_B = activationDescriptor.m_B;
+    };
+
+    void CheckDescriptor(const ActivationDescriptor& activationDescriptor)
+    {
+        BOOST_CHECK(activationDescriptor.m_Function == m_VisitorDescriptor.m_Function);
+        BOOST_CHECK_EQUAL(activationDescriptor.m_A, m_VisitorDescriptor.m_A);
+        BOOST_CHECK_EQUAL(activationDescriptor.m_B, m_VisitorDescriptor.m_B);
+    };
+
+    void VisitActivationLayer(const IConnectableLayer* layer,
+                              const ActivationDescriptor& activationDescriptor,
+                              const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(activationDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestNormalizationLayerVisitor : public TestLayerVisitor
+{
+private:
+    NormalizationDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestNormalizationLayerVisitor(const NormalizationDescriptor& normalizationDescriptor,
+                                           const char* name = nullptr)
+        : TestLayerVisitor(name)
+    {
+        m_VisitorDescriptor.m_NormChannelType = normalizationDescriptor.m_NormChannelType;
+        m_VisitorDescriptor.m_NormMethodType  = normalizationDescriptor.m_NormMethodType;
+        m_VisitorDescriptor.m_NormSize        = normalizationDescriptor.m_NormSize;
+        m_VisitorDescriptor.m_Alpha           = normalizationDescriptor.m_Alpha;
+        m_VisitorDescriptor.m_Beta            = normalizationDescriptor.m_Beta;
+        m_VisitorDescriptor.m_K               = normalizationDescriptor.m_K;
+        m_VisitorDescriptor.m_DataLayout      = normalizationDescriptor.m_DataLayout;
+    };
+
+    void CheckDescriptor(const NormalizationDescriptor& normalizationDescriptor)
+    {
+        BOOST_CHECK(normalizationDescriptor.m_NormChannelType == m_VisitorDescriptor.m_NormChannelType);
+        BOOST_CHECK(normalizationDescriptor.m_NormMethodType == m_VisitorDescriptor.m_NormMethodType);
+        BOOST_CHECK_EQUAL(normalizationDescriptor.m_NormSize, m_VisitorDescriptor.m_NormSize);
+        BOOST_CHECK_EQUAL(normalizationDescriptor.m_Alpha, m_VisitorDescriptor.m_Alpha);
+        BOOST_CHECK_EQUAL(normalizationDescriptor.m_Beta, m_VisitorDescriptor.m_Beta);
+        BOOST_CHECK_EQUAL(normalizationDescriptor.m_K, m_VisitorDescriptor.m_K);
+        BOOST_CHECK(normalizationDescriptor.m_DataLayout == m_VisitorDescriptor.m_DataLayout);
+    }
+
+    void VisitNormalizationLayer(const IConnectableLayer* layer,
+                                 const NormalizationDescriptor& normalizationDescriptor,
+                                 const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(normalizationDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestSoftmaxLayerVisitor : public TestLayerVisitor
+{
+private:
+    SoftmaxDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestSoftmaxLayerVisitor(const SoftmaxDescriptor& softmaxDescriptor, const char* name = nullptr)
+        : TestLayerVisitor(name)
+    {
+        m_VisitorDescriptor.m_Beta = softmaxDescriptor.m_Beta;
+    };
+
+    void CheckDescriptor(const SoftmaxDescriptor& softmaxDescriptor)
+    {
+        BOOST_CHECK_EQUAL(softmaxDescriptor.m_Beta, m_VisitorDescriptor.m_Beta);
+    }
+
+    void VisitSoftmaxLayer(const IConnectableLayer* layer,
+                           const SoftmaxDescriptor& softmaxDescriptor,
+                           const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(softmaxDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestSplitterLayerVisitor : public TestLayerVisitor
+{
+private:
+    ViewsDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestSplitterLayerVisitor(const ViewsDescriptor& splitterDescriptor, const char* name = nullptr)
+        : TestLayerVisitor(name)
+        , m_VisitorDescriptor(splitterDescriptor.GetNumViews(), splitterDescriptor.GetNumDimensions())
+    {
+        if (splitterDescriptor.GetNumViews() != m_VisitorDescriptor.GetNumViews())
+        {
+            BOOST_ERROR("Unequal number of views in splitter descriptor.");
+        }
+        else if (splitterDescriptor.GetNumDimensions() != m_VisitorDescriptor.GetNumDimensions())
+        {
+            BOOST_ERROR("Unequal number of dimensions in splitter descriptor.");
+        }
+        else
+        {
+            for (unsigned int i = 0; i < splitterDescriptor.GetNumViews(); ++i)
+            {
+                for (unsigned int j = 0; j < splitterDescriptor.GetNumDimensions(); ++j)
+                {
+                    m_VisitorDescriptor.SetViewOriginCoord(i, j, splitterDescriptor.GetViewOrigin(i)[j]);
+                    m_VisitorDescriptor.SetViewSize(i, j, splitterDescriptor.GetViewSizes(i)[j]);
+                }
+            }
+        }
+    };
+
+    void CheckDescriptor(const ViewsDescriptor& splitterDescriptor)
+    {
+
+        BOOST_CHECK_EQUAL(splitterDescriptor.GetNumViews(), m_VisitorDescriptor.GetNumViews());
+        BOOST_CHECK_EQUAL(splitterDescriptor.GetNumDimensions(), m_VisitorDescriptor.GetNumDimensions());
+
+        if (splitterDescriptor.GetNumViews() != m_VisitorDescriptor.GetNumViews())
+        {
+            BOOST_ERROR("Unequal number of views in splitter descriptor.");
+        }
+        else if (splitterDescriptor.GetNumDimensions() != m_VisitorDescriptor.GetNumDimensions())
+        {
+            BOOST_ERROR("Unequal number of dimensions in splitter descriptor.");
+        }
+        else
+        {
+            for (unsigned int i = 0; i < splitterDescriptor.GetNumViews(); ++i)
+            {
+                for (unsigned int j = 0; j < splitterDescriptor.GetNumDimensions(); ++j)
+                {
+                    BOOST_CHECK_EQUAL(splitterDescriptor.GetViewOrigin(i)[j], m_VisitorDescriptor.GetViewOrigin(i)[j]);
+                    BOOST_CHECK_EQUAL(splitterDescriptor.GetViewSizes(i)[j], m_VisitorDescriptor.GetViewSizes(i)[j]);
+                }
+            }
+        }
+    };
+
+    void VisitSplitterLayer(const IConnectableLayer* layer,
+                            const ViewsDescriptor& splitterDescriptor,
+                            const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(splitterDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestMergerLayerVisitor : public TestLayerVisitor
+{
+private:
+    OriginsDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestMergerLayerVisitor(const OriginsDescriptor& mergerDescriptor, const char* name = nullptr)
+        : TestLayerVisitor(name)
+        , m_VisitorDescriptor(mergerDescriptor.GetNumViews(), mergerDescriptor.GetNumDimensions())
+    {
+        m_VisitorDescriptor.SetConcatAxis(mergerDescriptor.GetConcatAxis());
+
+        if (mergerDescriptor.GetNumViews() != m_VisitorDescriptor.GetNumViews())
+        {
+            BOOST_ERROR("Unequal number of views in splitter descriptor.");
+        }
+        else if (mergerDescriptor.GetNumDimensions() != m_VisitorDescriptor.GetNumDimensions())
+        {
+            BOOST_ERROR("Unequal number of dimensions in splitter descriptor.");
+        }
+        else
+        {
+            for (unsigned int i = 0; i < mergerDescriptor.GetNumViews(); ++i)
+            {
+                for (unsigned int j = 0; j < mergerDescriptor.GetNumDimensions(); ++j)
+                {
+                    m_VisitorDescriptor.SetViewOriginCoord(i, j, mergerDescriptor.GetViewOrigin(i)[j]);
+                }
+            }
+        }
+    };
+
+    void CheckDescriptor(const OriginsDescriptor& mergerDescriptor)
+    {
+        BOOST_CHECK_EQUAL(mergerDescriptor.GetNumViews(), m_VisitorDescriptor.GetNumViews());
+        BOOST_CHECK_EQUAL(mergerDescriptor.GetNumDimensions(), m_VisitorDescriptor.GetNumDimensions());
+        BOOST_CHECK_EQUAL(mergerDescriptor.GetConcatAxis(), m_VisitorDescriptor.GetConcatAxis());
+
+        if (mergerDescriptor.GetNumViews() != m_VisitorDescriptor.GetNumViews())
+        {
+            BOOST_ERROR("Unequal number of views in splitter descriptor.");
+        }
+        else if (mergerDescriptor.GetNumDimensions() != m_VisitorDescriptor.GetNumDimensions())
+        {
+            BOOST_ERROR("Unequal number of dimensions in splitter descriptor.");
+        }
+        else
+        {
+            for (unsigned int i = 0; i < mergerDescriptor.GetNumViews(); ++i)
+            {
+                for (unsigned int j = 0; j < mergerDescriptor.GetNumDimensions(); ++j)
+                {
+                    BOOST_CHECK_EQUAL(mergerDescriptor.GetViewOrigin(i)[j], m_VisitorDescriptor.GetViewOrigin(i)[j]);
+                }
+            }
+        }
+    }
+
+    void VisitMergerLayer(const IConnectableLayer* layer,
+                          const OriginsDescriptor& mergerDescriptor,
+                          const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(mergerDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestResizeBilinearLayerVisitor : public TestLayerVisitor
+{
+private:
+    ResizeBilinearDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestResizeBilinearLayerVisitor(const ResizeBilinearDescriptor& resizeDesc, const char* name = nullptr)
+        : TestLayerVisitor(name)
+    {
+        m_VisitorDescriptor.m_TargetWidth  = resizeDesc.m_TargetWidth;
+        m_VisitorDescriptor.m_TargetHeight = resizeDesc.m_TargetHeight;
+        m_VisitorDescriptor.m_DataLayout   = resizeDesc.m_DataLayout;
+    };
+
+    void CheckDescriptor(const ResizeBilinearDescriptor& resizeDesc)
+    {
+        BOOST_CHECK_EQUAL(resizeDesc.m_TargetWidth, m_VisitorDescriptor.m_TargetWidth);
+        BOOST_CHECK_EQUAL(resizeDesc.m_TargetHeight, m_VisitorDescriptor.m_TargetHeight);
+        BOOST_CHECK(resizeDesc.m_DataLayout == m_VisitorDescriptor.m_DataLayout);
+    }
+
+    void VisitResizeBilinearLayer(const IConnectableLayer* layer,
+                                  const ResizeBilinearDescriptor& resizeDesc,
+                                  const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(resizeDesc);
+        CheckLayerName(name);
+    };
+};
+
+class TestL2NormalizationLayerVisitor : public TestLayerVisitor
+{
+private:
+    L2NormalizationDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestL2NormalizationLayerVisitor(const L2NormalizationDescriptor& desc, const char* name = nullptr)
+        : TestLayerVisitor(name)
+    {
+        m_VisitorDescriptor.m_DataLayout  = desc.m_DataLayout;
+    };
+
+    void CheckDescriptor(const L2NormalizationDescriptor& desc)
+    {
+        BOOST_CHECK(desc.m_DataLayout == m_VisitorDescriptor.m_DataLayout);
+    }
+
+    void VisitL2NormalizationLayer(const IConnectableLayer* layer,
+                                   const L2NormalizationDescriptor& desc,
+                                   const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(desc);
+        CheckLayerName(name);
+    };
+};
+
+class TestReshapeLayerVisitor : public TestLayerVisitor
+{
+private:
+    const ReshapeDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestReshapeLayerVisitor(const ReshapeDescriptor& reshapeDescriptor, const char* name = nullptr)
+        : TestLayerVisitor(name)
+        , m_VisitorDescriptor(reshapeDescriptor.m_TargetShape)
+    {};
+
+    void CheckDescriptor(const ReshapeDescriptor& reshapeDescriptor)
+    {
+        BOOST_CHECK_MESSAGE(reshapeDescriptor.m_TargetShape == m_VisitorDescriptor.m_TargetShape,
+                            reshapeDescriptor.m_TargetShape << " compared to " << m_VisitorDescriptor.m_TargetShape);
+    }
+
+    void VisitReshapeLayer(const IConnectableLayer* layer,
+                           const ReshapeDescriptor& reshapeDescriptor,
+                           const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(reshapeDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestSpaceToBatchNdLayerVisitor : public TestLayerVisitor
+{
+private:
+    SpaceToBatchNdDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestSpaceToBatchNdLayerVisitor(const SpaceToBatchNdDescriptor& desc, const char* name = nullptr)
+        : TestLayerVisitor(name)
+        , m_VisitorDescriptor(desc.m_BlockShape, desc.m_PadList)
+    {
+        m_VisitorDescriptor.m_DataLayout = desc.m_DataLayout;
+    };
+
+    void CheckDescriptor(const SpaceToBatchNdDescriptor& desc)
+    {
+        if (desc.m_BlockShape.size() == m_VisitorDescriptor.m_BlockShape.size())
+        {
+            for (unsigned int i = 0; i < desc.m_BlockShape.size(); ++i)
+            {
+                BOOST_CHECK_EQUAL(desc.m_BlockShape[i], m_VisitorDescriptor.m_BlockShape[i]);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for SpaceToBatchNdDescriptor m_BlockShape.");
+        }
+
+        if (desc.m_PadList.size() == m_VisitorDescriptor.m_PadList.size())
+        {
+            for (unsigned int i = 0; i < desc.m_PadList.size(); ++i)
+            {
+                BOOST_CHECK_EQUAL(desc.m_PadList[i].first, m_VisitorDescriptor.m_PadList[i].first);
+                BOOST_CHECK_EQUAL(desc.m_PadList[i].second, m_VisitorDescriptor.m_PadList[i].second);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for SpaceToBatchNdDescriptor m_PadList.");
+        }
+
+        BOOST_CHECK(desc.m_DataLayout == m_VisitorDescriptor.m_DataLayout);
+    }
+
+    void VisitSpaceToBatchNdLayer(const IConnectableLayer* layer,
+                                  const SpaceToBatchNdDescriptor& desc,
+                                  const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(desc);
+        CheckLayerName(name);
+    };
+};
+
+class TestMeanLayerVisitor : public TestLayerVisitor
+{
+private:
+    const MeanDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestMeanLayerVisitor(const MeanDescriptor& meanDescriptor, const char* name = nullptr)
+        : TestLayerVisitor(name)
+        , m_VisitorDescriptor(meanDescriptor.m_Axis, meanDescriptor.m_KeepDims)
+    {};
+
+    void CheckDescriptor(const MeanDescriptor& meanDescriptor)
+    {
+        if (meanDescriptor.m_Axis.size() == m_VisitorDescriptor.m_Axis.size())
+        {
+            for (unsigned int i = 0; i < meanDescriptor.m_Axis.size(); ++i)
+            {
+                BOOST_CHECK_EQUAL(meanDescriptor.m_Axis[i], m_VisitorDescriptor.m_Axis[i]);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for MeanDescriptor m_Axis.");
+        }
+
+        BOOST_CHECK_EQUAL(meanDescriptor.m_KeepDims, m_VisitorDescriptor.m_KeepDims);
+    }
+
+    void VisitMeanLayer(const IConnectableLayer* layer,
+                        const MeanDescriptor& meanDescriptor,
+                        const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(meanDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestPadLayerVisitor : public TestLayerVisitor
+{
+private:
+    const PadDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestPadLayerVisitor(const PadDescriptor& padDescriptor, const char* name = nullptr)
+        : TestLayerVisitor(name)
+        , m_VisitorDescriptor(padDescriptor.m_PadList)
+    {};
+
+    void CheckDescriptor(const PadDescriptor& padDescriptor)
+    {
+        if (padDescriptor.m_PadList.size() == m_VisitorDescriptor.m_PadList.size())
+        {
+            for (unsigned int i = 0; i < padDescriptor.m_PadList.size(); ++i)
+            {
+                BOOST_CHECK_EQUAL(padDescriptor.m_PadList[i].first, m_VisitorDescriptor.m_PadList[i].first);
+                BOOST_CHECK_EQUAL(padDescriptor.m_PadList[i].second, m_VisitorDescriptor.m_PadList[i].second);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for SpaceToBatchNdDescriptor m_PadList.");
+        }
+    }
+
+    void VisitPadLayer(const IConnectableLayer* layer,
+                       const PadDescriptor& padDescriptor,
+                       const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(padDescriptor);
+        CheckLayerName(name);
+    };
+};
+
+class TestStridedSliceLayerVisitor : public TestLayerVisitor
+{
+private:
+    StridedSliceDescriptor m_VisitorDescriptor;
+
+public:
+    explicit TestStridedSliceLayerVisitor(const StridedSliceDescriptor& desc, const char* name = nullptr)
+        : TestLayerVisitor(name)
+        , m_VisitorDescriptor(desc.m_Begin, desc.m_End, desc.m_Stride)
+    {
+        m_VisitorDescriptor.m_BeginMask      = desc.m_BeginMask;
+        m_VisitorDescriptor.m_EndMask        = desc.m_EndMask;
+        m_VisitorDescriptor.m_ShrinkAxisMask = desc.m_ShrinkAxisMask;
+        m_VisitorDescriptor.m_EllipsisMask   = desc.m_EllipsisMask;
+        m_VisitorDescriptor.m_NewAxisMask    = desc.m_NewAxisMask;
+        m_VisitorDescriptor.m_DataLayout     = desc.m_DataLayout;
+    };
+
+    void CheckDescriptor(const StridedSliceDescriptor& desc)
+    {
+        if (desc.m_Begin.size() == m_VisitorDescriptor.m_Begin.size())
+        {
+            for (unsigned int i = 0; i < desc.m_Begin.size(); ++i)
+            {
+                BOOST_CHECK_EQUAL(desc.m_Begin[i], m_VisitorDescriptor.m_Begin[i]);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for StridedSliceDescriptor m_Begin.");
+        }
+
+        if (desc.m_End.size() == m_VisitorDescriptor.m_End.size())
+        {
+            for (unsigned int i = 0; i < desc.m_End.size(); ++i)
+            {
+                BOOST_CHECK_EQUAL(desc.m_End[i], m_VisitorDescriptor.m_End[i]);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for StridedSliceDescriptor m_End.");
+        }
+
+        if (desc.m_Stride.size() == m_VisitorDescriptor.m_Stride.size())
+        {
+            for (unsigned int i = 0; i < desc.m_Stride.size(); ++i)
+            {
+                BOOST_CHECK_EQUAL(desc.m_Stride[i], m_VisitorDescriptor.m_Stride[i]);
+            }
+        }
+        else
+        {
+            BOOST_ERROR("Unequal vector size for StridedSliceDescriptor m_Stride.");
+        }
+
+        BOOST_CHECK_EQUAL(desc.m_BeginMask, m_VisitorDescriptor.m_BeginMask);
+        BOOST_CHECK_EQUAL(desc.m_EndMask, m_VisitorDescriptor.m_EndMask);
+        BOOST_CHECK_EQUAL(desc.m_ShrinkAxisMask, m_VisitorDescriptor.m_ShrinkAxisMask);
+        BOOST_CHECK_EQUAL(desc.m_EllipsisMask, m_VisitorDescriptor.m_EllipsisMask);
+        BOOST_CHECK_EQUAL(desc.m_NewAxisMask, m_VisitorDescriptor.m_NewAxisMask);
+        BOOST_CHECK(desc.m_DataLayout == m_VisitorDescriptor.m_DataLayout);
+    }
+
+    void VisitStridedSliceLayer(const IConnectableLayer* layer,
+                                const StridedSliceDescriptor& desc,
+                                const char* name = nullptr) override
+    {
+        CheckLayerPointer(layer);
+        CheckDescriptor(desc);
+        CheckLayerName(name);
+    };
+};
+
+} //namespace armnn