diff options
Diffstat (limited to 'src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp')
| -rw-r--r-- | src/armnn/test/TestNameAndDescriptorLayerVisitor.hpp | 675 |
1 files changed, 675 insertions, 0 deletions
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 |