/// An ActivationDescriptor for the ActivationLayer.
struct ActivationDescriptor
{
- ActivationDescriptor() : m_Function(ActivationFunction::Sigmoid), m_A(0), m_B(0) {}
+ ActivationDescriptor()
+ : m_Function(ActivationFunction::Sigmoid)
+ , m_A(0)
+ , m_B(0)
+ {}
+
+ bool operator ==(const ActivationDescriptor &rhs) const
+ {
+ return m_Function == rhs.m_Function && m_A == rhs.m_B && m_B == rhs.m_B;
+ }
/// @brief The activation function to use
/// (Sigmoid, TanH, Linear, ReLu, BoundedReLu, SoftReLu, LeakyReLu, Abs, Sqrt, Square).
struct ArgMinMaxDescriptor
{
ArgMinMaxDescriptor()
- : m_Function(ArgMinMaxFunction::Min)
- , m_Axis(-1)
+ : m_Function(ArgMinMaxFunction::Min)
+ , m_Axis(-1)
{}
+ bool operator ==(const ArgMinMaxDescriptor &rhs) const
+ {
+ return m_Function == rhs.m_Function && m_Axis == rhs.m_Axis;
+ }
+
/// Specify if the function is to find Min or Max.
ArgMinMaxFunction m_Function;
/// Axis to reduce across the input tensor.
{
PermuteDescriptor()
: m_DimMappings{}
- {
- }
+ {}
+
PermuteDescriptor(const PermutationVector& dimMappings)
: m_DimMappings(dimMappings)
+ {}
+
+ bool operator ==(const PermuteDescriptor &rhs) const
{
+ return m_DimMappings.IsEqual(rhs.m_DimMappings);
}
+
/// @brief Indicates how to translate tensor elements from a given source into the target destination, when
/// source and target potentially have different memory layouts e.g. {0U, 3U, 1U, 2U}.
PermutationVector m_DimMappings;
struct SoftmaxDescriptor
{
SoftmaxDescriptor()
- : m_Beta(1.0f)
- , m_Axis(-1)
+ : m_Beta(1.0f)
+ , m_Axis(-1)
{}
+ bool operator ==(const SoftmaxDescriptor& rhs) const
+ {
+ return m_Beta == rhs.m_Beta && m_Axis == rhs.m_Axis;
+ }
+
/// Exponentiation value.
float m_Beta;
/// Scalar, defaulted to the last index (-1), specifying the dimension the activation will be performed on.
OriginsDescriptor& operator=(OriginsDescriptor rhs);
+ bool operator ==(const OriginsDescriptor& rhs) const;
+
/// @Brief Set the view origin coordinates. The arguments are: view, dimension, value.
/// If the view is greater than or equal to GetNumViews(), then the view argument is out of range.
/// If the coord is greater than or equal to GetNumDimensions(), then the coord argument is out of range.
~ViewsDescriptor();
ViewsDescriptor& operator=(ViewsDescriptor rhs);
+
+ bool operator ==(const ViewsDescriptor& rhs) const;
+
/// @Brief Set the view origin coordinates. The arguments are: view, dimension, value.
/// If the view is greater than or equal to GetNumViews(), then the view argument is out of range.
/// If the coord is greater than or equal to GetNumDimensions(), then the coord argument is out of range.
struct Pooling2dDescriptor
{
Pooling2dDescriptor()
- : m_PoolType(PoolingAlgorithm::Max)
- , m_PadLeft(0)
- , m_PadRight(0)
- , m_PadTop(0)
- , m_PadBottom(0)
- , m_PoolWidth(0)
- , m_PoolHeight(0)
- , m_StrideX(0)
- , m_StrideY(0)
- , m_OutputShapeRounding(OutputShapeRounding::Floor)
- , m_PaddingMethod(PaddingMethod::Exclude)
- , m_DataLayout(DataLayout::NCHW)
+ : m_PoolType(PoolingAlgorithm::Max)
+ , m_PadLeft(0)
+ , m_PadRight(0)
+ , m_PadTop(0)
+ , m_PadBottom(0)
+ , m_PoolWidth(0)
+ , m_PoolHeight(0)
+ , m_StrideX(0)
+ , m_StrideY(0)
+ , m_OutputShapeRounding(OutputShapeRounding::Floor)
+ , m_PaddingMethod(PaddingMethod::Exclude)
+ , m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const Pooling2dDescriptor& rhs) const
+ {
+ return m_PoolType == rhs.m_PoolType &&
+ m_PadLeft == rhs.m_PadLeft &&
+ m_PadRight == rhs.m_PadRight &&
+ m_PadTop == rhs.m_PadTop &&
+ m_PadBottom == rhs.m_PadBottom &&
+ m_PoolWidth == rhs.m_PoolWidth &&
+ m_PoolHeight == rhs.m_PoolHeight &&
+ m_StrideX == rhs.m_StrideX &&
+ m_StrideY == rhs.m_StrideY &&
+ m_OutputShapeRounding == rhs.m_OutputShapeRounding &&
+ m_PaddingMethod == rhs.m_PaddingMethod &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
/// The pooling algorithm to use (Max. Average, L2).
PoolingAlgorithm m_PoolType;
/// Padding left value in the width dimension.
struct FullyConnectedDescriptor
{
FullyConnectedDescriptor()
- : m_BiasEnabled(false)
- , m_TransposeWeightMatrix(false)
+ : m_BiasEnabled(false)
+ , m_TransposeWeightMatrix(false)
{}
+ bool operator ==(const FullyConnectedDescriptor& rhs) const
+ {
+ return m_BiasEnabled == rhs.m_BiasEnabled && m_TransposeWeightMatrix == rhs.m_TransposeWeightMatrix;
+ }
+
/// Enable/disable bias.
bool m_BiasEnabled;
/// Enable/disable transpose weight matrix.
struct Convolution2dDescriptor
{
Convolution2dDescriptor()
- : m_PadLeft(0)
- , m_PadRight(0)
- , m_PadTop(0)
- , m_PadBottom(0)
- , m_StrideX(0)
- , m_StrideY(0)
- , m_DilationX(1)
- , m_DilationY(1)
- , m_BiasEnabled(false)
- , m_DataLayout(DataLayout::NCHW)
+ : m_PadLeft(0)
+ , m_PadRight(0)
+ , m_PadTop(0)
+ , m_PadBottom(0)
+ , m_StrideX(0)
+ , m_StrideY(0)
+ , m_DilationX(1)
+ , m_DilationY(1)
+ , m_BiasEnabled(false)
+ , m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const Convolution2dDescriptor& rhs) const
+ {
+ return m_PadLeft == rhs.m_PadLeft &&
+ m_PadRight == rhs.m_PadRight &&
+ m_PadTop == rhs.m_PadTop &&
+ m_PadBottom == rhs.m_PadBottom &&
+ m_StrideX == rhs.m_StrideX &&
+ m_StrideY == rhs.m_StrideY &&
+ m_DilationX == rhs.m_DilationX &&
+ m_DilationY == rhs.m_DilationY &&
+ m_BiasEnabled == rhs.m_BiasEnabled &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Padding left value in the width dimension.
uint32_t m_PadLeft;
/// Padding right value in the width dimension.
struct DepthwiseConvolution2dDescriptor
{
DepthwiseConvolution2dDescriptor()
- : m_PadLeft(0)
- , m_PadRight(0)
- , m_PadTop(0)
- , m_PadBottom(0)
- , m_StrideX(0)
- , m_StrideY(0)
- , m_DilationX(1)
- , m_DilationY(1)
- , m_BiasEnabled(false)
- , m_DataLayout(DataLayout::NCHW)
+ : m_PadLeft(0)
+ , m_PadRight(0)
+ , m_PadTop(0)
+ , m_PadBottom(0)
+ , m_StrideX(0)
+ , m_StrideY(0)
+ , m_DilationX(1)
+ , m_DilationY(1)
+ , m_BiasEnabled(false)
+ , m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const DepthwiseConvolution2dDescriptor& rhs) const
+ {
+ return m_PadLeft == rhs.m_PadLeft &&
+ m_PadRight == rhs.m_PadRight &&
+ m_PadTop == rhs.m_PadTop &&
+ m_PadBottom == rhs.m_PadBottom &&
+ m_StrideX == rhs.m_StrideX &&
+ m_StrideY == rhs.m_StrideY &&
+ m_DilationX == rhs.m_DilationX &&
+ m_DilationY == rhs.m_DilationY &&
+ m_BiasEnabled == rhs.m_BiasEnabled &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Padding left value in the width dimension.
uint32_t m_PadLeft;
/// Padding right value in the width dimension.
struct DetectionPostProcessDescriptor
{
DetectionPostProcessDescriptor()
- : m_MaxDetections(0)
- , m_MaxClassesPerDetection(1)
- , m_DetectionsPerClass(1)
- , m_NmsScoreThreshold(0)
- , m_NmsIouThreshold(0)
- , m_NumClasses(0)
- , m_UseRegularNms(false)
- , m_ScaleX(0)
- , m_ScaleY(0)
- , m_ScaleW(0)
- , m_ScaleH(0)
+ : m_MaxDetections(0)
+ , m_MaxClassesPerDetection(1)
+ , m_DetectionsPerClass(1)
+ , m_NmsScoreThreshold(0)
+ , m_NmsIouThreshold(0)
+ , m_NumClasses(0)
+ , m_UseRegularNms(false)
+ , m_ScaleX(0)
+ , m_ScaleY(0)
+ , m_ScaleW(0)
+ , m_ScaleH(0)
{}
+ bool operator ==(const DetectionPostProcessDescriptor& rhs) const
+ {
+ return m_MaxDetections == rhs.m_MaxDetections &&
+ m_MaxClassesPerDetection == rhs.m_MaxClassesPerDetection &&
+ m_DetectionsPerClass == rhs.m_DetectionsPerClass &&
+ m_NmsScoreThreshold == rhs.m_NmsScoreThreshold &&
+ m_NmsIouThreshold == rhs.m_NmsIouThreshold &&
+ m_NumClasses == rhs.m_NumClasses &&
+ m_UseRegularNms == rhs.m_UseRegularNms &&
+ m_ScaleX == rhs.m_ScaleX &&
+ m_ScaleY == rhs.m_ScaleY &&
+ m_ScaleW == rhs.m_ScaleW &&
+ m_ScaleH == rhs.m_ScaleH;
+ }
+
/// Maximum numbers of detections.
uint32_t m_MaxDetections;
/// Maximum numbers of classes per detection, used in Fast NMS.
struct NormalizationDescriptor
{
NormalizationDescriptor()
- : m_NormChannelType(NormalizationAlgorithmChannel::Across)
- , m_NormMethodType(NormalizationAlgorithmMethod::LocalBrightness)
- , m_NormSize(0)
- , m_Alpha(0.f)
- , m_Beta(0.f)
- , m_K(0.f)
- , m_DataLayout(DataLayout::NCHW)
+ : m_NormChannelType(NormalizationAlgorithmChannel::Across)
+ , m_NormMethodType(NormalizationAlgorithmMethod::LocalBrightness)
+ , m_NormSize(0)
+ , m_Alpha(0.f)
+ , m_Beta(0.f)
+ , m_K(0.f)
+ , m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const NormalizationDescriptor& rhs) const
+ {
+ return m_NormChannelType == rhs.m_NormChannelType &&
+ m_NormMethodType == rhs.m_NormMethodType &&
+ m_NormSize == rhs.m_NormSize &&
+ m_Alpha == rhs.m_Alpha &&
+ m_Beta == rhs.m_Beta &&
+ m_K == rhs.m_K &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Normalization channel algorithm to use (Across, Within).
NormalizationAlgorithmChannel m_NormChannelType;
/// Normalization method algorithm to use (LocalBrightness, LocalContrast).
struct L2NormalizationDescriptor
{
L2NormalizationDescriptor()
- : m_Eps(1e-12f)
- , m_DataLayout(DataLayout::NCHW)
+ : m_Eps(1e-12f)
+ , m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const L2NormalizationDescriptor& rhs) const
+ {
+ return m_Eps == rhs.m_Eps && m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Used to avoid dividing by zero.
float m_Eps;
/// The data layout to be used (NCHW, NHWC).
struct BatchNormalizationDescriptor
{
BatchNormalizationDescriptor()
- : m_Eps(0.0001f)
- , m_DataLayout(DataLayout::NCHW)
+ : m_Eps(0.0001f)
+ , m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const BatchNormalizationDescriptor& rhs) const
+ {
+ return m_Eps == rhs.m_Eps && m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Value to add to the variance. Used to avoid dividing by zero.
float m_Eps;
/// The data layout to be used (NCHW, NHWC).
, m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const InstanceNormalizationDescriptor& rhs) const
+ {
+ return m_Gamma == rhs.m_Gamma &&
+ m_Beta == rhs.m_Beta &&
+ m_Eps == rhs.m_Eps &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Gamma, the scale scalar value applied for the normalized tensor. Defaults to 1.0.
float m_Gamma;
/// Beta, the offset scalar value applied for the normalized tensor. Defaults to 1.0.
, m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const BatchToSpaceNdDescriptor& rhs) const
+ {
+ return m_BlockShape == rhs.m_BlockShape &&
+ m_Crops == rhs.m_Crops &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Block shape values.
std::vector<unsigned int> m_BlockShape;
/// The values to crop from the input dimension.
/// A FakeQuantizationDescriptor for the FakeQuantizationLayer.
struct FakeQuantizationDescriptor
{
- FakeQuantizationDescriptor()
- : m_Min(-6.0f)
- , m_Max(6.0f)
+ FakeQuantizationDescriptor()
+ : m_Min(-6.0f)
+ , m_Max(6.0f)
{}
+ bool operator ==(const FakeQuantizationDescriptor& rhs) const
+ {
+ return m_Min == rhs.m_Min && m_Max == rhs.m_Max;
+ }
+
/// Minimum value.
float m_Min;
/// Maximum value.
struct ResizeBilinearDescriptor
{
ResizeBilinearDescriptor()
- : m_TargetWidth(0)
- , m_TargetHeight(0)
- , m_DataLayout(DataLayout::NCHW)
+ : m_TargetWidth(0)
+ , m_TargetHeight(0)
+ , m_DataLayout(DataLayout::NCHW)
{}
/// Target width value.
struct ResizeDescriptor
{
ResizeDescriptor()
- : m_TargetWidth(0)
- , m_TargetHeight(0)
- , m_Method(ResizeMethod::NearestNeighbor)
- , m_DataLayout(DataLayout::NCHW)
+ : m_TargetWidth(0)
+ , m_TargetHeight(0)
+ , m_Method(ResizeMethod::NearestNeighbor)
+ , m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const ResizeDescriptor& rhs) const
+ {
+ return m_TargetWidth == rhs.m_TargetWidth &&
+ m_TargetHeight == rhs.m_TargetHeight &&
+ m_Method == rhs.m_Method &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Target width value.
uint32_t m_TargetWidth;
/// Target height value.
struct ReshapeDescriptor
{
ReshapeDescriptor()
- : m_TargetShape()
+ : m_TargetShape()
{}
ReshapeDescriptor(const TensorShape& shape)
- : m_TargetShape(shape)
+ : m_TargetShape(shape)
{}
+ bool operator ==(const ReshapeDescriptor& rhs) const
+ {
+ return m_TargetShape == rhs.m_TargetShape;
+ }
+
/// Target shape value.
TensorShape m_TargetShape;
};
struct SpaceToBatchNdDescriptor
{
SpaceToBatchNdDescriptor()
- : m_BlockShape({1, 1})
- , m_PadList({{0, 0}, {0, 0}})
- , m_DataLayout(DataLayout::NCHW)
+ : m_BlockShape({1, 1})
+ , m_PadList({{0, 0}, {0, 0}})
+ , m_DataLayout(DataLayout::NCHW)
{}
SpaceToBatchNdDescriptor(const std::vector<unsigned int>& blockShape,
const std::vector<std::pair<unsigned int, unsigned int>>& padList)
- : m_BlockShape(blockShape)
- , m_PadList(padList)
- , m_DataLayout(DataLayout::NCHW)
+ : m_BlockShape(blockShape)
+ , m_PadList(padList)
+ , m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const SpaceToBatchNdDescriptor& rhs) const
+ {
+ return m_BlockShape == rhs.m_BlockShape &&
+ m_PadList == rhs.m_PadList &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Block shape value.
std::vector<unsigned int> m_BlockShape;
/// @brief Specifies the padding values for the input dimension:
, m_DataLayout(dataLayout)
{}
+ bool operator ==(const SpaceToDepthDescriptor& rhs) const
+ {
+ return m_BlockSize == rhs.m_BlockSize && m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Scalar specifying the input block size. It must be >= 1
unsigned int m_BlockSize;
struct LstmDescriptor
{
LstmDescriptor()
- : m_ActivationFunc(1) // 0: None, 1: Relu, 3: Relu6, 4: Tanh, 6: Sigmoid
- , m_ClippingThresCell(0.0)
- , m_ClippingThresProj(0.0)
- , m_CifgEnabled(true)
- , m_PeepholeEnabled(false)
- , m_ProjectionEnabled(false)
- , m_LayerNormEnabled(false)
+ : m_ActivationFunc(1) // 0: None, 1: Relu, 3: Relu6, 4: Tanh, 6: Sigmoid
+ , m_ClippingThresCell(0.0)
+ , m_ClippingThresProj(0.0)
+ , m_CifgEnabled(true)
+ , m_PeepholeEnabled(false)
+ , m_ProjectionEnabled(false)
+ , m_LayerNormEnabled(false)
{}
+ bool operator ==(const LstmDescriptor& rhs) const
+ {
+ return m_ActivationFunc == rhs.m_ActivationFunc &&
+ m_ClippingThresCell == rhs.m_ClippingThresCell &&
+ m_ClippingThresProj == rhs.m_ClippingThresProj &&
+ m_CifgEnabled == rhs.m_CifgEnabled &&
+ m_PeepholeEnabled == rhs.m_PeepholeEnabled &&
+ m_LayerNormEnabled == rhs.m_LayerNormEnabled;
+ }
+
/// @brief The activation function to use.
/// 0: None, 1: Relu, 3: Relu6, 4: Tanh, 6: Sigmoid.
uint32_t m_ActivationFunc;
struct MeanDescriptor
{
MeanDescriptor()
- : m_Axis()
- , m_KeepDims(false)
+ : m_Axis()
+ , m_KeepDims(false)
{}
MeanDescriptor(const std::vector<unsigned int>& axis, bool keepDims)
- : m_Axis(axis)
- , m_KeepDims(keepDims)
+ : m_Axis(axis)
+ , m_KeepDims(keepDims)
{}
+ bool operator ==(const MeanDescriptor& rhs) const
+ {
+ return m_Axis == rhs.m_Axis && m_KeepDims == rhs.m_KeepDims;
+ }
+
/// Values for the dimensions to reduce.
std::vector<unsigned int> m_Axis;
/// Enable/disable keep dimensions. If true, then the reduced dimensions that are of length 1 are kept.
{}
PadDescriptor(const std::vector<std::pair<unsigned int, unsigned int>>& padList, const float& padValue = 0)
- : m_PadList(padList), m_PadValue(padValue)
+ : m_PadList(padList)
+ , m_PadValue(padValue)
{}
+ bool operator ==(const PadDescriptor& rhs) const
+ {
+ return m_PadList == rhs.m_PadList && m_PadValue == rhs.m_PadValue;
+ }
+
/// @brief Specifies the padding for input dimension.
/// First is the number of values to add before the tensor in the dimension.
/// Second is the number of values to add after the tensor in the dimension.
SliceDescriptor() : SliceDescriptor({}, {})
{}
+ bool operator ==(const SliceDescriptor& rhs) const
+ {
+ return m_Begin == rhs.m_Begin && m_Size == rhs.m_Size;
+ }
+
/// Beginning indices of the slice in each dimension.
std::vector<unsigned int> m_Begin;
struct StackDescriptor
{
StackDescriptor()
- : m_Axis(0)
- , m_NumInputs(0)
- , m_InputShape()
+ : m_Axis(0)
+ , m_NumInputs(0)
+ , m_InputShape()
{}
StackDescriptor(uint32_t axis, uint32_t numInputs, const TensorShape& inputShape)
- : m_Axis(axis)
- , m_NumInputs(numInputs)
- , m_InputShape(inputShape)
+ : m_Axis(axis)
+ , m_NumInputs(numInputs)
+ , m_InputShape(inputShape)
{}
+ bool operator ==(const StackDescriptor& rhs) const
+ {
+ return m_Axis == rhs.m_Axis &&
+ m_NumInputs == rhs.m_NumInputs &&
+ m_InputShape == rhs.m_InputShape;
+ }
+
/// 0-based axis along which to stack the input tensors.
uint32_t m_Axis;
/// Number of input tensors.
StridedSliceDescriptor(const std::vector<int>& begin,
const std::vector<int>& end,
const std::vector<int>& stride)
- : m_Begin(begin)
- , m_End(end)
- , m_Stride(stride)
- , m_BeginMask(0)
- , m_EndMask(0)
- , m_ShrinkAxisMask(0)
- , m_EllipsisMask(0)
- , m_NewAxisMask(0)
- , m_DataLayout(DataLayout::NCHW)
+ : m_Begin(begin)
+ , m_End(end)
+ , m_Stride(stride)
+ , m_BeginMask(0)
+ , m_EndMask(0)
+ , m_ShrinkAxisMask(0)
+ , m_EllipsisMask(0)
+ , m_NewAxisMask(0)
+ , m_DataLayout(DataLayout::NCHW)
{}
StridedSliceDescriptor()
- : StridedSliceDescriptor({}, {}, {})
+ : StridedSliceDescriptor({}, {}, {})
{}
+ bool operator ==(const StridedSliceDescriptor& rhs) const
+ {
+ return m_Begin == rhs.m_Begin &&
+ m_End == rhs.m_End &&
+ m_Stride == rhs.m_Stride &&
+ m_BeginMask == rhs.m_BeginMask &&
+ m_EndMask == rhs.m_EndMask &&
+ m_ShrinkAxisMask == rhs.m_ShrinkAxisMask &&
+ m_EllipsisMask == rhs.m_EllipsisMask &&
+ m_NewAxisMask == rhs.m_NewAxisMask &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
int GetStartForAxis(const TensorShape& inputShape, unsigned int axis) const;
int GetStopForAxis(const TensorShape& inputShape,
unsigned int axis,
m_DataLayout(DataLayout::NCHW)
{}
+ bool operator ==(const TransposeConvolution2dDescriptor& rhs) const
+ {
+ return m_PadLeft == rhs.m_PadLeft &&
+ m_PadRight == rhs.m_PadRight &&
+ m_PadTop == rhs.m_PadTop &&
+ m_PadBottom == rhs.m_PadBottom &&
+ m_StrideX == rhs.m_StrideX &&
+ m_StrideY == rhs.m_StrideY &&
+ m_BiasEnabled == rhs.m_BiasEnabled &&
+ m_DataLayout == rhs.m_DataLayout;
+ }
+
/// Padding left value in the width dimension.
uint32_t m_PadLeft;
/// Padding right value in the width dimension.
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;
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();
#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
//
#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)
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()
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)
projects / platform / upstream / armnn.git / commitdiff