IVGCVSW-3991 Make Descriptor objects comparable and refactor LayerVisitor tests

* Implemented operator==() for Descriptor structs
* Refactored TestNameAndDescriptorLayerVisitor to eliminate code duplication
  by using templates and taking advantage of the fact that descriptor objects
  can now all be compared the same way using ==
* Cleaned up TestNameOnlylayerVisitor by moving all test cases for layers
  that require a descriptor to TestNameAndDescriptorLayerVisitor

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

5 files changed, 315 insertions, 1176 deletions

diff --git a/src/armnn/Descriptors.cpp b/src/armnn/Descriptors.cpp
index a6339cf08e..381d040683 100644
--- a/src/armnn/Descriptors.cpp
+++ b/src/armnn/Descriptors.cpp
@@ -124,6 +124,29 @@ OriginsDescriptor& OriginsDescriptor::operator=(OriginsDescriptor rhs)
     return *this;
 }
 
+bool OriginsDescriptor::operator==(const OriginsDescriptor& rhs) const
+{
+    if (GetNumViews()      != rhs.GetNumViews() ||
+        GetNumDimensions() != rhs.GetNumDimensions() ||
+        GetConcatAxis()    != rhs.GetConcatAxis())
+    {
+        return false;
+    }
+
+    for (unsigned int i = 0u; i < GetNumViews(); ++i)
+    {
+        for (unsigned int j = 0u; j < GetNumDimensions(); ++j)
+        {
+            if (GetViewOrigin(i)[j] != rhs.GetViewOrigin(i)[j])
+            {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
 void OriginsDescriptor::SetConcatAxis(unsigned int concatAxis)
 {
     m_ConcatAxis = concatAxis;
@@ -240,6 +263,27 @@ ViewsDescriptor& ViewsDescriptor::operator=(ViewsDescriptor rhs)
     return *this;
 }
 
+bool ViewsDescriptor::operator==(const ViewsDescriptor& rhs) const
+{
+    if (GetNumViews() != rhs.GetNumViews() || GetNumDimensions() != rhs.GetNumDimensions())
+    {
+        return false;
+    }
+
+    for (unsigned int i = 0u; i < GetNumViews(); ++i)
+    {
+        for (unsigned int j = 0u; j < GetNumDimensions(); ++j)
+        {
+            if (GetViewOrigin(i)[j] != rhs.GetViewOrigin(i)[j] || GetViewSizes(i)[j] != rhs.GetViewSizes(i)[j])
+            {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
 uint32_t ViewsDescriptor::GetNumViews() const
 {
     return m_Origins.GetNumViews();
diff --git a/src/armnn/test/TestNameAndDescriptorLayerVisitor.cpp b/src/armnn/test/TestNameAndDescriptorLayerVisitor.cpp
index e2bfb01733..0b126235e8 100644
--- a/src/armnn/test/TestNameAndDescriptorLayerVisitor.cpp
+++ b/src/armnn/test/TestNameAndDescriptorLayerVisitor.cpp
@@ -5,475 +5,261 @@
 #include "TestNameAndDescriptorLayerVisitor.hpp"
 #include "Network.hpp"
 
-namespace armnn
-{
+#include <armnn/Exceptions.hpp>
 
-void Set2dDataValues(SplitterDescriptor descriptor, uint32_t value)
+namespace
 {
-    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(OriginsDescriptor& descriptor, uint32_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);
-        }
-    }
+#define TEST_CASE_CHECK_LAYER_VISITOR_NAME_AND_DESCRIPTOR(name) \
+BOOST_AUTO_TEST_CASE(Check##name##LayerVisitorNameAndDescriptor) \
+{ \
+    const char* layerName = "name##Layer"; \
+    armnn::name##Descriptor descriptor = GetDescriptor<armnn::name##Descriptor>(); \
+    Test##name##LayerVisitor visitor(descriptor, layerName); \
+    armnn::Network net; \
+    armnn::IConnectableLayer *const layer = net.Add##name##Layer(descriptor, layerName); \
+    layer->Accept(visitor); \
 }
 
-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);
+#define TEST_CASE_CHECK_LAYER_VISITOR_NAME_NULLPTR_AND_DESCRIPTOR(name) \
+BOOST_AUTO_TEST_CASE(Check##name##LayerVisitorNameNullptrAndDescriptor) \
+{ \
+    armnn::name##Descriptor descriptor = GetDescriptor<armnn::name##Descriptor>(); \
+    Test##name##LayerVisitor visitor(descriptor); \
+    armnn::Network net; \
+    armnn::IConnectableLayer *const layer = net.Add##name##Layer(descriptor); \
+    layer->Accept(visitor); \
 }
 
-BOOST_AUTO_TEST_CASE(CheckPermuteLayerVisitorNameNullAndDescriptor)
-{
-    PermuteDescriptor descriptor({0, 1, 2, 3});
-    TestPermuteLayerVisitor visitor(descriptor);
-    Network net;
+#define TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(name) \
+TEST_CASE_CHECK_LAYER_VISITOR_NAME_AND_DESCRIPTOR(name) \
+TEST_CASE_CHECK_LAYER_VISITOR_NAME_NULLPTR_AND_DESCRIPTOR(name)
 
-    IConnectableLayer *const layer = net.AddPermuteLayer(descriptor);
-    layer->Accept(visitor);
-}
+template<typename Descriptor> Descriptor GetDescriptor();
 
-BOOST_AUTO_TEST_CASE(CheckBatchToSpaceNdLayerVisitorNameAndDescriptor)
+template<>
+armnn::ActivationDescriptor GetDescriptor<armnn::ActivationDescriptor>()
 {
-    const char* layerName = "BatchToSpaceNdLayer";
-    BatchToSpaceNdDescriptor descriptor({1, 1}, {{0, 0}, {0, 0}});
-    descriptor.m_DataLayout = armnn::DataLayout::NHWC;
-    TestBatchToSpaceNdLayerVisitor visitor(descriptor, layerName);
-    Network net;
+    armnn::ActivationDescriptor descriptor;
+    descriptor.m_Function = armnn::ActivationFunction::Linear;
+    descriptor.m_A        = 2.0f;
+    descriptor.m_B        = 2.0f;
 
-    IConnectableLayer *const layer = net.AddBatchToSpaceNdLayer(descriptor, layerName);
-    layer->Accept(visitor);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckBatchToSpaceNdLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::ArgMinMaxDescriptor GetDescriptor<armnn::ArgMinMaxDescriptor>()
 {
-    BatchToSpaceNdDescriptor descriptor({1, 1}, {{0, 0}, {0, 0}});
-    descriptor.m_DataLayout = armnn::DataLayout::NHWC;
-    TestBatchToSpaceNdLayerVisitor visitor(descriptor);
-    Network net;
+    armnn::ArgMinMaxDescriptor descriptor;
+    descriptor.m_Function = armnn::ArgMinMaxFunction::Max;
+    descriptor.m_Axis     = 1;
 
-    IConnectableLayer *const layer = net.AddBatchToSpaceNdLayer(descriptor);
-    layer->Accept(visitor);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckPooling2dLayerVisitorNameAndDescriptor)
+template<>
+armnn::BatchToSpaceNdDescriptor GetDescriptor<armnn::BatchToSpaceNdDescriptor>()
 {
-    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);
+    return armnn::BatchToSpaceNdDescriptor({ 1, 1 }, {{ 0, 0 }, { 0, 0 }});
 }
 
-BOOST_AUTO_TEST_CASE(CheckPooling2dLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::ConcatDescriptor GetDescriptor<armnn::ConcatDescriptor>()
 {
-    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);
-}
+    armnn::ConcatDescriptor descriptor(2, 2);
+    for (unsigned int i = 0u; i < descriptor.GetNumViews(); ++i)
+    {
+        for (unsigned int j = 0u; j < descriptor.GetNumDimensions(); ++j)
+        {
+            descriptor.SetViewOriginCoord(i, j, i);
+        }
+    }
 
-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);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckSoftmaxLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::InstanceNormalizationDescriptor GetDescriptor<armnn::InstanceNormalizationDescriptor>()
 {
-    SoftmaxDescriptor descriptor;
-    descriptor.m_Beta = 2;
-    TestSoftmaxLayerVisitor visitor(descriptor);
-    Network net;
-
-    IConnectableLayer *const layer = net.AddSoftmaxLayer(descriptor);
-    layer->Accept(visitor);
-}
+    armnn::InstanceNormalizationDescriptor descriptor;
+    descriptor.m_Gamma      = 1.0f;
+    descriptor.m_Beta       = 2.0f;
+    descriptor.m_Eps        = 0.0001f;
+    descriptor.m_DataLayout = armnn::DataLayout::NHWC;
 
-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);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckSplitterLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::L2NormalizationDescriptor GetDescriptor<armnn::L2NormalizationDescriptor>()
 {
-    SplitterDescriptor descriptor(2, 2);
-    Set2dDataValues(descriptor, 1);
-    TestSplitterLayerVisitor visitor(descriptor);
-    Network net;
+    armnn::L2NormalizationDescriptor descriptor;
+    descriptor.m_Eps        = 0.0001f;
+    descriptor.m_DataLayout = armnn::DataLayout::NHWC;
 
-    IConnectableLayer *const layer = net.AddSplitterLayer(descriptor);
-    layer->Accept(visitor);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckConcatLayerVisitorNameAndDescriptor)
+template<>
+armnn::MeanDescriptor GetDescriptor<armnn::MeanDescriptor>()
 {
-    const char* layerName = "ConcatLayer";
-    OriginsDescriptor descriptor(2, 2);
-    Set2dDataValues(descriptor, 1);
-    descriptor.SetConcatAxis(1);
-    TestConcatLayerVisitor visitor(descriptor, layerName);
-    Network net;
-
-    IConnectableLayer *const layer = net.AddConcatLayer(descriptor, layerName);
-    layer->Accept(visitor);
+    return armnn::MeanDescriptor({ 1, 2, }, true);
 }
 
-BOOST_AUTO_TEST_CASE(CheckConcatLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::NormalizationDescriptor GetDescriptor<armnn::NormalizationDescriptor>()
 {
-    OriginsDescriptor descriptor(2, 2);
-    Set2dDataValues(descriptor, 1);
-    descriptor.SetConcatAxis(1);
-    TestConcatLayerVisitor visitor(descriptor);
-    Network net;
-
-    IConnectableLayer *const layer = net.AddConcatLayer(descriptor);
-    layer->Accept(visitor);
-}
+    armnn::NormalizationDescriptor descriptor;
+    descriptor.m_NormChannelType = armnn::NormalizationAlgorithmChannel::Within;
+    descriptor.m_NormMethodType  = armnn::NormalizationAlgorithmMethod::LocalContrast;
+    descriptor.m_NormSize        = 1u;
+    descriptor.m_Alpha           = 1.0f;
+    descriptor.m_Beta            = 1.0f;
+    descriptor.m_K               = 1.0f;
+    descriptor.m_DataLayout      = armnn::DataLayout::NHWC;
 
-BOOST_AUTO_TEST_CASE(CheckResizeLayerVisitorNameAndDescriptor)
-{
-    const char* layerName = "ResizeLayer";
-    ResizeDescriptor descriptor;
-    descriptor.m_TargetHeight = 1;
-    descriptor.m_TargetWidth  = 1;
-    descriptor.m_DataLayout   = DataLayout::NHWC;
-    TestResizeLayerVisitor visitor(descriptor, layerName);
-    Network net;
-
-    IConnectableLayer *const layer = net.AddResizeLayer(descriptor, layerName);
-    layer->Accept(visitor);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckResizeLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::PadDescriptor GetDescriptor<armnn::PadDescriptor>()
 {
-    ResizeDescriptor descriptor;
-    descriptor.m_TargetHeight = 1;
-    descriptor.m_TargetWidth  = 1;
-    descriptor.m_DataLayout   = DataLayout::NHWC;
-    TestResizeLayerVisitor visitor(descriptor);
-    Network net;
-
-    IConnectableLayer *const layer = net.AddResizeLayer(descriptor);
-    layer->Accept(visitor);
+    return armnn::PadDescriptor({{ 1, 2 }, { 3, 4 }});
 }
 
-BOOST_AUTO_TEST_CASE(CheckInstanceNormalizationLayerVisitorNameAndDescriptor)
+template<>
+armnn::PermuteDescriptor GetDescriptor<armnn::PermuteDescriptor>()
 {
-    const char* layerName = "InstanceNormalizationLayer";
-    InstanceNormalizationDescriptor descriptor;
-    descriptor.m_DataLayout = DataLayout::NHWC;
-    TestInstanceNormalizationLayerVisitor visitor(descriptor, layerName);
-    Network net;
-
-    IConnectableLayer *const layer = net.AddInstanceNormalizationLayer(descriptor, layerName);
-    layer->Accept(visitor);
+    return armnn::PermuteDescriptor({ 0, 1, 2, 3 });
 }
 
-BOOST_AUTO_TEST_CASE(CheckInstanceNormalizationLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::Pooling2dDescriptor GetDescriptor<armnn::Pooling2dDescriptor>()
 {
-    InstanceNormalizationDescriptor descriptor;
-    descriptor.m_DataLayout = DataLayout::NHWC;
-    TestInstanceNormalizationLayerVisitor visitor(descriptor);
-    Network net;
+    armnn::Pooling2dDescriptor descriptor;
+    descriptor.m_PoolType            = armnn::PoolingAlgorithm::Max;
+    descriptor.m_PadLeft             = 1u;
+    descriptor.m_PadRight            = 1u;
+    descriptor.m_PadTop              = 1u;
+    descriptor.m_PadBottom           = 1u;
+    descriptor.m_PoolWidth           = 1u;
+    descriptor.m_PoolHeight          = 1u;
+    descriptor.m_StrideX             = 1u;
+    descriptor.m_StrideY             = 1u;
+    descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Ceiling;
+    descriptor.m_PaddingMethod       = armnn::PaddingMethod::IgnoreValue;
+    descriptor.m_DataLayout          = armnn::DataLayout::NHWC;
 
-    IConnectableLayer *const layer = net.AddInstanceNormalizationLayer(descriptor);
-    layer->Accept(visitor);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckL2NormalizationLayerVisitorNameAndDescriptor)
+template<>
+armnn::ReshapeDescriptor GetDescriptor<armnn::ReshapeDescriptor>()
 {
-    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);
+    return armnn::ReshapeDescriptor({ 1, 2, 3, 4 });
 }
 
-BOOST_AUTO_TEST_CASE(CheckL2NormalizationLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::ResizeDescriptor GetDescriptor<armnn::ResizeDescriptor>()
 {
-    L2NormalizationDescriptor descriptor;
-    descriptor.m_DataLayout = DataLayout::NHWC;
-    TestL2NormalizationLayerVisitor visitor(descriptor);
-    Network net;
+    armnn::ResizeDescriptor descriptor;
+    descriptor.m_TargetHeight = 1u;
+    descriptor.m_TargetWidth  = 1u;
+    descriptor.m_DataLayout   = armnn::DataLayout::NHWC;
 
-    IConnectableLayer *const layer = net.AddL2NormalizationLayer(descriptor);
-    layer->Accept(visitor);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckLogSoftmaxLayerVisitorNameAndDescriptor)
+template<>
+armnn::SliceDescriptor GetDescriptor<armnn::SliceDescriptor>()
 {
-    const char* layerName = "LogSoftmaxLayer";
-
-    LogSoftmaxDescriptor descriptor;
-    descriptor.m_Beta = 2.0f;
-    descriptor.m_Axis = 1;
-
-    TestLogSoftmaxLayerVisitor visitor(descriptor, layerName);
-    Network net;
-
-    IConnectableLayer *const layer = net.AddLogSoftmaxLayer(descriptor, layerName);
-    layer->Accept(visitor);
+    return armnn::SliceDescriptor({ 1, 1 }, { 2, 2 });
 }
 
-BOOST_AUTO_TEST_CASE(CheckLogSoftmaxLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::SoftmaxDescriptor GetDescriptor<armnn::SoftmaxDescriptor>()
 {
-    LogSoftmaxDescriptor descriptor;
+    armnn::SoftmaxDescriptor descriptor;
     descriptor.m_Beta = 2.0f;
-    descriptor.m_Axis = 1;
-
-    TestLogSoftmaxLayerVisitor visitor(descriptor);
-    Network net;
+    descriptor.m_Axis = -1;
 
-    IConnectableLayer *const layer = net.AddLogSoftmaxLayer(descriptor);
-    layer->Accept(visitor);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckReshapeLayerVisitorNameAndDescriptor)
+template<>
+armnn::SpaceToBatchNdDescriptor GetDescriptor<armnn::SpaceToBatchNdDescriptor>()
 {
-    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);
+    return armnn::SpaceToBatchNdDescriptor({ 2, 2 }, {{ 1, 1 } , { 1, 1 }});
 }
 
-BOOST_AUTO_TEST_CASE(CheckReshapeLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::SpaceToDepthDescriptor GetDescriptor<armnn::SpaceToDepthDescriptor>()
 {
-    ReshapeDescriptor descriptor({1, 2, 3, 4});
-    TestReshapeLayerVisitor visitor(descriptor);
-    Network net;
-
-    IConnectableLayer *const layer = net.AddReshapeLayer(descriptor);
-    layer->Accept(visitor);
+    return armnn::SpaceToDepthDescriptor(2, armnn::DataLayout::NHWC);
 }
 
-BOOST_AUTO_TEST_CASE(CheckSpaceToBatchNdLayerVisitorNameAndDescriptor)
+template<>
+armnn::SplitterDescriptor GetDescriptor<armnn::SplitterDescriptor>()
 {
-    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;
+    armnn::SplitterDescriptor descriptor(2, 2);
+    for (unsigned int i = 0u; i < descriptor.GetNumViews(); ++i)
+    {
+        for (unsigned int j = 0u; j < descriptor.GetNumDimensions(); ++j)
+        {
+            descriptor.SetViewOriginCoord(i, j, i);
+            descriptor.SetViewSize(i, j, 1);
+        }
+    }
 
-    IConnectableLayer *const layer = net.AddPadLayer(descriptor, layerName);
-    layer->Accept(visitor);
+    return descriptor;
 }
 
-BOOST_AUTO_TEST_CASE(CheckPadLayerVisitorNameNullAndDescriptor)
+template<>
+armnn::StackDescriptor GetDescriptor<armnn::StackDescriptor>()
 {
-    PadDescriptor descriptor({{1, 2}, {3, 4}});
-    TestPadLayerVisitor visitor(descriptor);
-    Network net;
-
-    IConnectableLayer *const layer = net.AddPadLayer(descriptor);
-    layer->Accept(visitor);
+    return armnn::StackDescriptor(1, 2, { 2, 2 });
 }
 
-BOOST_AUTO_TEST_CASE(CheckStridedSliceLayerVisitorNameAndDescriptor)
+template<>
+armnn::StridedSliceDescriptor GetDescriptor<armnn::StridedSliceDescriptor>()
 {
-    const char* layerName = "StridedSliceLayer";
-    StridedSliceDescriptor descriptor({1, 2}, {3, 4}, {3, 4});
+    armnn::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;
+    descriptor.m_DataLayout     = armnn::DataLayout::NHWC;
 
-    IConnectableLayer *const layer = net.AddStridedSliceLayer(descriptor, layerName);
-    layer->Accept(visitor);
+    return descriptor;
 }
 
-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);
-}
+} // anonymous namespace
 
-BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE(TestNameAndDescriptorLayerVisitor)
 
-} //namespace armnn
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Activation)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(ArgMinMax)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(DepthToSpace)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(BatchToSpaceNd)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Concat)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(InstanceNormalization)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(L2Normalization)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(LogSoftmax)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Mean)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Normalization)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Pad)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Permute)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Pooling2d)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Reshape)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Resize)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Slice)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Softmax)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(SpaceToBatchNd)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(SpaceToDepth)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Splitter)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(Stack)
+TEST_SUITE_NAME_AND_DESCRIPTOR_LAYER_VISITOR(StridedSlice)
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp b/src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp
index e46aa34e29..aefcba5f59 100644
--- a/src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp
+++ b/src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp
@@ -4,734 +4,64 @@
 //
 #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 TestConcatLayerVisitor : public TestLayerVisitor
-{
-private:
-    OriginsDescriptor m_VisitorDescriptor;
-
-public:
-    explicit TestConcatLayerVisitor(const OriginsDescriptor& concatDescriptor, const char* name = nullptr)
-        : TestLayerVisitor(name)
-        , m_VisitorDescriptor(concatDescriptor.GetNumViews(), concatDescriptor.GetNumDimensions())
-    {
-        m_VisitorDescriptor.SetConcatAxis(concatDescriptor.GetConcatAxis());
-
-        if (concatDescriptor.GetNumViews() != m_VisitorDescriptor.GetNumViews())
-        {
-            BOOST_ERROR("Unequal number of views in splitter descriptor.");
-        }
-        else if (concatDescriptor.GetNumDimensions() != m_VisitorDescriptor.GetNumDimensions())
-        {
-            BOOST_ERROR("Unequal number of dimensions in splitter descriptor.");
-        }
-        else
-        {
-            for (unsigned int i = 0; i < concatDescriptor.GetNumViews(); ++i)
-            {
-                for (unsigned int j = 0; j < concatDescriptor.GetNumDimensions(); ++j)
-                {
-                    m_VisitorDescriptor.SetViewOriginCoord(i, j, concatDescriptor.GetViewOrigin(i)[j]);
-                }
-            }
-        }
-    };
-
-    void CheckDescriptor(const OriginsDescriptor& concatDescriptor)
-    {
-        BOOST_CHECK_EQUAL(concatDescriptor.GetNumViews(), m_VisitorDescriptor.GetNumViews());
-        BOOST_CHECK_EQUAL(concatDescriptor.GetNumDimensions(), m_VisitorDescriptor.GetNumDimensions());
-        BOOST_CHECK_EQUAL(concatDescriptor.GetConcatAxis(), m_VisitorDescriptor.GetConcatAxis());
-
-        if (concatDescriptor.GetNumViews() != m_VisitorDescriptor.GetNumViews())
-        {
-            BOOST_ERROR("Unequal number of views in splitter descriptor.");
-        }
-        else if (concatDescriptor.GetNumDimensions() != m_VisitorDescriptor.GetNumDimensions())
-        {
-            BOOST_ERROR("Unequal number of dimensions in splitter descriptor.");
-        }
-        else
-        {
-            for (unsigned int i = 0; i < concatDescriptor.GetNumViews(); ++i)
-            {
-                for (unsigned int j = 0; j < concatDescriptor.GetNumDimensions(); ++j)
-                {
-                    BOOST_CHECK_EQUAL(concatDescriptor.GetViewOrigin(i)[j], m_VisitorDescriptor.GetViewOrigin(i)[j]);
-                }
-            }
-        }
-    }
-
-    void VisitConcatLayer(const IConnectableLayer* layer,
-                          const OriginsDescriptor& concatDescriptor,
-                          const char* name = nullptr) override
-    {
-        CheckLayerPointer(layer);
-        CheckDescriptor(concatDescriptor);
-        CheckLayerName(name);
-    };
-};
-
-class TestResizeLayerVisitor : public TestLayerVisitor
-{
-private:
-    ResizeDescriptor m_VisitorDescriptor;
-
-public:
-    explicit TestResizeLayerVisitor(const ResizeDescriptor& descriptor, const char* name = nullptr)
-        : TestLayerVisitor(name)
-    {
-        m_VisitorDescriptor.m_Method       = descriptor.m_Method;
-        m_VisitorDescriptor.m_TargetWidth  = descriptor.m_TargetWidth;
-        m_VisitorDescriptor.m_TargetHeight = descriptor.m_TargetHeight;
-        m_VisitorDescriptor.m_DataLayout   = descriptor.m_DataLayout;
-    };
-
-    void CheckDescriptor(const ResizeDescriptor& descriptor)
-    {
-        BOOST_CHECK(descriptor.m_Method       == m_VisitorDescriptor.m_Method);
-        BOOST_CHECK(descriptor.m_TargetWidth  == m_VisitorDescriptor.m_TargetWidth);
-        BOOST_CHECK(descriptor.m_TargetHeight == m_VisitorDescriptor.m_TargetHeight);
-        BOOST_CHECK(descriptor.m_DataLayout   == m_VisitorDescriptor.m_DataLayout);
-    }
-
-    void VisitResizeLayer(const IConnectableLayer* layer,
-                          const ResizeDescriptor& descriptor,
-                          const char* name = nullptr) override
-    {
-        CheckLayerPointer(layer);
-        CheckDescriptor(descriptor);
-        CheckLayerName(name);
-    };
-};
-
-class TestInstanceNormalizationLayerVisitor : public TestLayerVisitor
-{
-private:
-    InstanceNormalizationDescriptor m_VisitorDescriptor;
-
-public:
-    explicit TestInstanceNormalizationLayerVisitor(const InstanceNormalizationDescriptor& desc,
-                                                   const char* name = nullptr)
-        : TestLayerVisitor(name)
-    {
-        m_VisitorDescriptor.m_Beta        = desc.m_Beta;
-        m_VisitorDescriptor.m_Gamma       = desc.m_Gamma;
-        m_VisitorDescriptor.m_Eps         = desc.m_Eps;
-        m_VisitorDescriptor.m_DataLayout  = desc.m_DataLayout;
-    };
-
-    void CheckDescriptor(const InstanceNormalizationDescriptor& desc)
-    {
-        BOOST_CHECK(desc.m_Beta       == m_VisitorDescriptor.m_Beta);
-        BOOST_CHECK(desc.m_Gamma      == m_VisitorDescriptor.m_Gamma);
-        BOOST_CHECK(desc.m_Eps        == m_VisitorDescriptor.m_Eps);
-        BOOST_CHECK(desc.m_DataLayout == m_VisitorDescriptor.m_DataLayout);
-    }
-
-    void VisitInstanceNormalizationLayer(const IConnectableLayer* layer,
-                                         const InstanceNormalizationDescriptor& desc,
-                                         const char* name = nullptr) override
-    {
-        CheckLayerPointer(layer);
-        CheckDescriptor(desc);
-        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 TestLogSoftmaxLayerVisitor : public TestLayerVisitor
-{
-private:
-    LogSoftmaxDescriptor m_VisitorDescriptor;
-
-public:
-    explicit TestLogSoftmaxLayerVisitor(const LogSoftmaxDescriptor& descriptor, const char* name = nullptr)
-        : TestLayerVisitor(name)
-        , m_VisitorDescriptor(descriptor) {}
-
-    void CheckDescriptor(const LogSoftmaxDescriptor& descriptor)
-    {
-        BOOST_CHECK_EQUAL(descriptor.m_Beta, m_VisitorDescriptor.m_Beta);
-        BOOST_CHECK_EQUAL(descriptor.m_Axis, m_VisitorDescriptor.m_Axis);
-    }
-
-    void VisitLogSoftmaxLayer(const IConnectableLayer* layer,
-                              const LogSoftmaxDescriptor& descriptor,
-                              const char* name = nullptr) override
-    {
-        CheckLayerPointer(layer);
-        CheckDescriptor(descriptor);
-        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);
-    }
+#include <armnn/ArmNN.hpp>
 
-    void VisitStridedSliceLayer(const IConnectableLayer* layer,
-                                const StridedSliceDescriptor& desc,
-                                const char* name = nullptr) override
-    {
-        CheckLayerPointer(layer);
-        CheckDescriptor(desc);
-        CheckLayerName(name);
-    };
-};
+#include <boost/test/unit_test.hpp>
 
-} //namespace armnn
+namespace
+{
+
+#define DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(name) \
+class Test##name##LayerVisitor : public armnn::TestLayerVisitor \
+{ \
+private: \
+    using Descriptor = armnn::name##Descriptor; \
+    Descriptor m_Descriptor; \
+    \
+    bool CheckDescriptor(const Descriptor& descriptor) \
+    { \
+        return descriptor == m_Descriptor; \
+    } \
+\
+public: \
+    explicit Test##name##LayerVisitor(const Descriptor& descriptor, \
+                                      const char* layerName = nullptr) \
+        : armnn::TestLayerVisitor(layerName) \
+        , m_Descriptor(descriptor) {}; \
+    \
+    void Visit##name##Layer(const armnn::IConnectableLayer* layer, \
+                            const Descriptor& descriptor, \
+                            const char* layerName = nullptr) override \
+    { \
+        CheckLayerPointer(layer); \
+        CheckDescriptor(descriptor); \
+        CheckLayerName(layerName); \
+    } \
+};
+
+} // anonymous namespace
+
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Activation)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(ArgMinMax)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(BatchToSpaceNd)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Concat)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(DepthToSpace)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(InstanceNormalization)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(L2Normalization)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(LogSoftmax)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Mean)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Normalization)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Pad)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Permute)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Pooling2d)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Reshape)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Resize)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Slice)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Softmax)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(SpaceToBatchNd)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(SpaceToDepth)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Splitter)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(Stack)
+DECLARE_TEST_NAME_AND_DESCRIPTOR_LAYER_VISITOR_CLASS(StridedSlice)
diff --git a/src/armnn/test/TestNameOnlyLayerVisitor.cpp b/src/armnn/test/TestNameOnlyLayerVisitor.cpp
index 2217a32edf..6bc2dc7c65 100644
--- a/src/armnn/test/TestNameOnlyLayerVisitor.cpp
+++ b/src/armnn/test/TestNameOnlyLayerVisitor.cpp
@@ -12,54 +12,48 @@
 namespace
 {
 
-#define ADD_LAYER_METHOD_1_PARAM(name) net.Add##name##Layer("name##Layer")
-#define ADD_LAYER_METHOD_2_PARAM(name) net.Add##name##Layer(armnn::name##Descriptor(), "name##Layer")
-
-#define TEST_CASE_CHECK_LAYER_VISITOR_NAME(name, numParams) \
+#define TEST_CASE_CHECK_LAYER_VISITOR_NAME(name) \
 BOOST_AUTO_TEST_CASE(Check##name##LayerVisitorName) \
 { \
     Test##name##LayerVisitor visitor("name##Layer"); \
     armnn::Network net; \
-    armnn::IConnectableLayer *const layer = ADD_LAYER_METHOD_##numParams##_PARAM(name); \
+    armnn::IConnectableLayer *const layer = net.Add##name##Layer("name##Layer"); \
     layer->Accept(visitor); \
 }
 
-#define ADD_LAYER_METHOD_NULLPTR_1_PARAM(name) net.Add##name##Layer()
-#define ADD_LAYER_METHOD_NULLPTR_2_PARAM(name) net.Add##name##Layer(armnn::name##Descriptor())
-
-#define TEST_CASE_CHECK_LAYER_VISITOR_NAME_NULLPTR(name, numParams) \
+#define TEST_CASE_CHECK_LAYER_VISITOR_NAME_NULLPTR(name) \
 BOOST_AUTO_TEST_CASE(Check##name##LayerVisitorNameNullptr) \
 { \
     Test##name##LayerVisitor visitor; \
     armnn::Network net; \
-    armnn::IConnectableLayer *const layer = ADD_LAYER_METHOD_NULLPTR_##numParams##_PARAM(name); \
+    armnn::IConnectableLayer *const layer = net.Add##name##Layer(); \
     layer->Accept(visitor); \
 }
 
-#define TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(name) \
-TEST_CASE_CHECK_LAYER_VISITOR_NAME(name, 1) \
-TEST_CASE_CHECK_LAYER_VISITOR_NAME_NULLPTR(name, 1)
-
-#define TEST_SUITE_NAME_ONLY_LAYER_VISITOR_2_PARAM(name) \
-TEST_CASE_CHECK_LAYER_VISITOR_NAME(name, 2) \
-TEST_CASE_CHECK_LAYER_VISITOR_NAME_NULLPTR(name, 2)
+#define TEST_SUITE_NAME_ONLY_LAYER_VISITOR(name) \
+TEST_CASE_CHECK_LAYER_VISITOR_NAME(name) \
+TEST_CASE_CHECK_LAYER_VISITOR_NAME_NULLPTR(name)
 
 } // anonymous namespace
 
 BOOST_AUTO_TEST_SUITE(TestNameOnlyLayerVisitor)
 
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Addition)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_2_PARAM(DepthToSpace)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Division)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Equal)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Floor)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Gather)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Greater)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Maximum)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Minimum)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Multiplication)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Rsqrt)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_2_PARAM(Slice)
-TEST_SUITE_NAME_ONLY_LAYER_VISITOR_1_PARAM(Subtraction)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Abs)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Addition)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Dequantize)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Division)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Equal)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Floor)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Gather)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Greater)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Maximum)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Merge)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Minimum)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Multiplication)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Prelu)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Quantize)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Rsqrt)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Subtraction)
+TEST_SUITE_NAME_ONLY_LAYER_VISITOR(Switch)
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/armnn/test/TestNameOnlyLayerVisitor.hpp b/src/armnn/test/TestNameOnlyLayerVisitor.hpp
index 4e0aa2f989..a772cb3283 100644
--- a/src/armnn/test/TestNameOnlyLayerVisitor.hpp
+++ b/src/armnn/test/TestNameOnlyLayerVisitor.hpp
@@ -9,51 +9,36 @@
 namespace
 {
 
-// Defines a visitor function with 1 required parameter to be used
-// with layers that do not have a descriptor
-#define VISIT_METHOD_1_PARAM(name) \
-void Visit##name##Layer(const armnn::IConnectableLayer* layer, const char* layerName = nullptr) override
-
-// Defines a visitor function with 2 required parameters to be used
-// with layers that have a descriptor
-#define VISIT_METHOD_2_PARAM(name) \
-void Visit##name##Layer(const armnn::IConnectableLayer* layer, \
-                        const armnn::name##Descriptor&, \
-                        const char* layerName = nullptr) override
-
-#define TEST_LAYER_VISITOR(name, numVisitorParams) \
+#define DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(name) \
 class Test##name##LayerVisitor : public armnn::TestLayerVisitor \
 { \
 public: \
     explicit Test##name##LayerVisitor(const char* layerName = nullptr) : armnn::TestLayerVisitor(layerName) {}; \
     \
-    VISIT_METHOD_##numVisitorParams##_PARAM(name) \
+    void Visit##name##Layer(const armnn::IConnectableLayer* layer, \
+                            const char* layerName = nullptr) override \
     { \
         CheckLayerPointer(layer); \
         CheckLayerName(layerName); \
     } \
 };
 
-// Defines a test layer visitor class for a layer, of a given name,
-// that does not require a descriptor
-#define TEST_LAYER_VISITOR_1_PARAM(name) TEST_LAYER_VISITOR(name, 1)
-
-// Defines a test layer visitor class for a layer, of a given name,
-// that requires a descriptor
-#define TEST_LAYER_VISITOR_2_PARAM(name) TEST_LAYER_VISITOR(name, 2)
-
 } // anonymous namespace
 
-TEST_LAYER_VISITOR_1_PARAM(Addition)
-TEST_LAYER_VISITOR_2_PARAM(DepthToSpace)
-TEST_LAYER_VISITOR_1_PARAM(Division)
-TEST_LAYER_VISITOR_1_PARAM(Equal)
-TEST_LAYER_VISITOR_1_PARAM(Floor)
-TEST_LAYER_VISITOR_1_PARAM(Gather)
-TEST_LAYER_VISITOR_1_PARAM(Greater)
-TEST_LAYER_VISITOR_1_PARAM(Maximum)
-TEST_LAYER_VISITOR_1_PARAM(Minimum)
-TEST_LAYER_VISITOR_1_PARAM(Multiplication)
-TEST_LAYER_VISITOR_1_PARAM(Rsqrt)
-TEST_LAYER_VISITOR_2_PARAM(Slice)
-TEST_LAYER_VISITOR_1_PARAM(Subtraction)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Abs)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Addition)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Dequantize)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Division)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Equal)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Floor)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Gather)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Greater)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Maximum)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Merge)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Minimum)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Multiplication)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Prelu)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Quantize)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Rsqrt)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Subtraction)
+DECLARE_TEST_NAME_ONLY_LAYER_VISITOR_CLASS(Switch)