Compute Library
 19.08
arm_compute::test::validation Namespace Reference

Namespaces

 reference
 

Data Structures

class  AbsoluteTolerance
 Class reprensenting an absolute tolerance value. More...
 
struct  CannyEdgeParameters
 Parameters of Canny edge algorithm. More...
 
struct  compare
 
struct  compare< AbsoluteTolerance< U > >
 Compare values with an absolute tolerance. More...
 
struct  compare< RelativeTolerance< U > >
 Compare values with a relative tolerance. More...
 
struct  compare_base
 
struct  HarrisCornersParameters
 Parameters of Harris Corners algorithm. More...
 
struct  is_floating_point
 
struct  is_floating_point< half >
 
class  RelativeTolerance
 Class reprensenting a relative tolerance value. More...
 

Typedefs

template<typename T >
using CLAbsLayerFixture = AbsValidationFixture< CLTensor, CLAccessor, CLAbsLayer, T >
 
template<typename T >
using CLAbsoluteDifferenceFixture = AbsoluteDifferenceValidationFixture< CLTensor, CLAccessor, CLAbsoluteDifference, T >
 
template<typename T1 >
using CLAccumulateFixture = AccumulateValidationFixture< CLTensor, CLAccessor, CLAccumulate, T1, int16_t >
 
template<typename T1 >
using CLAccumulateWeightedFixture = AccumulateWeightedValidationFixture< CLTensor, CLAccessor, CLAccumulateWeighted, T1, uint8_t >
 
template<typename T1 >
using CLAccumulateSquaredFixture = AccumulateSquaredValidationFixture< CLTensor, CLAccessor, CLAccumulateSquared, T1, int16_t >
 
template<typename T >
using CLActivationLayerFixture = ActivationValidationFixture< CLTensor, CLAccessor, CLActivationLayer, T >
 [CLActivationLayerFixture snippet] More...
 
template<typename T >
using CLArgMinMaxValidationFixture = ArgMinMaxValidationFixture< CLTensor, CLAccessor, CLArgMinMaxLayer, T >
 
template<typename T >
using CLArithmeticAdditionFixture = ArithmeticAdditionValidationFixture< CLTensor, CLAccessor, CLArithmeticAddition, T >
 
template<typename T >
using CLArithmeticAdditionBroadcastFixture = ArithmeticAdditionBroadcastValidationFixture< CLTensor, CLAccessor, CLArithmeticAddition, T >
 
template<typename T >
using CLArithmeticDivisionFixture = ArithmeticDivisionValidationFixture< CLTensor, CLAccessor, CLArithmeticDivision, T >
 
template<typename T >
using CLArithmeticDivisionBroadcastFixture = ArithmeticDivisionBroadcastValidationFixture< CLTensor, CLAccessor, CLArithmeticDivision, T >
 
template<typename T >
using CLArithmeticSubtractionFixture = ArithmeticSubtractionValidationFixture< CLTensor, CLAccessor, CLArithmeticSubtraction, T >
 
template<typename T >
using CLArithmeticSubtractionBroadcastFixture = ArithmeticSubtractionBroadcastValidationFixture< CLTensor, CLAccessor, CLArithmeticSubtraction, T >
 
template<typename T >
using CLBatchConcatenateLayerFixture = ConcatenateLayerValidationFixture< CLTensor, ICLTensor, CLAccessor, CLConcatenateLayer, T >
 
template<typename T >
using CLBatchNormalizationLayerFixture = BatchNormalizationLayerValidationFixture< CLTensor, CLAccessor, CLBatchNormalizationLayer, T >
 
template<typename T >
using CLBatchNormalizationLayerFusionFixture = BatchNormalizationLayerFusionValidationFixture< CLTensor, CLAccessor, CLConvolutionLayer, CLFuseBatchNormalization, T >
 
template<typename T >
using CLBatchToSpaceLayerFixture = BatchToSpaceLayerValidationFixture< CLTensor, CLAccessor, CLBatchToSpaceLayer, T >
 
template<typename T >
using CLBitwiseAndFixture = BitwiseAndValidationFixture< CLTensor, CLAccessor, CLBitwiseAnd, T >
 
template<typename T >
using CLBitwiseNotFixture = BitwiseNotValidationFixture< CLTensor, CLAccessor, CLBitwiseNot, T >
 
template<typename T >
using CLBitwiseOrFixture = BitwiseOrValidationFixture< CLTensor, CLAccessor, CLBitwiseOr, T >
 
template<typename T >
using CLBitwiseXorFixture = BitwiseXorValidationFixture< CLTensor, CLAccessor, CLBitwiseXor, T >
 
template<typename T >
using CLBoundingBoxTransformFixture = BoundingBoxTransformFixture< CLTensor, CLAccessor, CLBoundingBoxTransform, T >
 
template<typename T >
using CLBox3x3Fixture = Box3x3ValidationFixture< CLTensor, CLAccessor, CLBox3x3, T >
 
template<typename T >
using CLCannyEdgeFixture = CannyEdgeValidationFixture< CLTensor, CLAccessor, CLKeyPointArray, CLCannyEdge, T >
 
template<typename T >
using CLCastToU8Fixture = CastValidationFixture< CLTensor, CLAccessor, CLCast, T, uint8_t >
 
template<typename T >
using CLCastToS8Fixture = CastValidationFixture< CLTensor, CLAccessor, CLCast, T, int8_t >
 
template<typename T >
using CLCastToU16Fixture = CastValidationFixture< CLTensor, CLAccessor, CLCast, T, uint16_t >
 
template<typename T >
using CLCastToS16Fixture = CastValidationFixture< CLTensor, CLAccessor, CLCast, T, int16_t >
 
template<typename T >
using CLCastToU32Fixture = CastValidationFixture< CLTensor, CLAccessor, CLCast, T, uint32_t >
 
template<typename T >
using CLCastToS32Fixture = CastValidationFixture< CLTensor, CLAccessor, CLCast, T, int32_t >
 
template<typename T >
using CLCastToF16Fixture = CastValidationFixture< CLTensor, CLAccessor, CLCast, T, half >
 
template<typename T >
using CLCastToF32Fixture = CastValidationFixture< CLTensor, CLAccessor, CLCast, T, float >
 
template<typename T >
using CLChannelCombineFixture = ChannelCombineValidationFixture< CLMultiImage, CLTensor, CLAccessor, CLChannelCombine, T >
 
template<typename T >
using CLChannelExtractFixture = ChannelExtractValidationFixture< CLMultiImage, CLTensor, CLAccessor, CLChannelExtract, T >
 
template<typename T >
using CLChannelShuffleLayerFixture = ChannelShuffleLayerValidationFixture< CLTensor, CLAccessor, CLChannelShuffleLayer, T >
 
using CLCol2Im = CLSynthetizeFunction< CLCol2ImKernel >
 
template<typename T >
using CLCol2ImFixture = Col2ImValidationFixture< CLTensor, CLAccessor, CLCol2Im, T, true >
 
template<typename T >
using CLColorConvertFixture = ColorConvertValidationFixture< CLMultiImage, CLTensor, CLAccessor, CLColorConvert, T >
 
template<typename T >
using CLComparisonFixture = ComparisonValidationFixture< CLTensor, CLAccessor, CLComparison, T >
 
template<typename T >
using CLConvertFullyConnectedWeightsFixture = ConvertFullyConnectedWeightsValidationFixture< CLTensor, CLAccessor, CLConvertFullyConnectedWeights, T >
 
template<typename T >
using CLConvolutionFixture = ConvolutionSquareValidationFixture< CLTensor, CLAccessor, CLConvolution3x3, T >
 
template<typename T >
using CLGEMMConvolutionLayerFixture = ConvolutionValidationFixture< CLTensor, CLAccessor, CLGEMMConvolutionLayer, T >
 
template<typename T >
using CLCopyFixture = CopyFixture< CLTensor, CLAccessor, CLCopy, T >
 
template<typename T >
using CLCropResizeFixture = CropResizeFixture< CLTensor, CLAccessor, CLCropResize, T >
 
template<typename T >
using CLDeconvolutionLayerFixture4x4 = DeconvolutionValidationFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, 4, 4 >
 
template<typename T >
using CLDeconvolutionLayerFixture3x3 = DeconvolutionValidationFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, 3, 3 >
 
template<typename T >
using CLDeconvolutionLayerFixture2x2 = DeconvolutionValidationFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, 2, 2 >
 
template<typename T >
using CLDeconvolutionLayerFixture1x1 = DeconvolutionValidationFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, 1, 1 >
 
template<typename T >
using CLDeconvolutionLayerQuantizedFixture3x3 = DeconvolutionValidationQuantizedFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, 3, 3 >
 
template<typename T >
using CLDeconvolutionLayerQuantizedFixture2x2 = DeconvolutionValidationQuantizedFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, 2, 2 >
 
template<typename T >
using CLDeconvolutionLayerQuantizedFixture1x1 = DeconvolutionValidationQuantizedFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, 1, 1 >
 
template<typename T >
using CLDepthConcatenateLayerFixture = ConcatenateLayerValidationFixture< CLTensor, ICLTensor, CLAccessor, CLConcatenateLayer, T >
 
template<typename T >
using CLDepthConvertLayerToU16Fixture = DepthConvertLayerValidationFixture< CLTensor, CLAccessor, CLDepthConvertLayer, T, uint16_t >
 
template<typename T >
using CLDepthConvertLayerToS16Fixture = DepthConvertLayerValidationFixture< CLTensor, CLAccessor, CLDepthConvertLayer, T, int16_t >
 
template<typename T >
using CLDepthConvertLayerToS32Fixture = DepthConvertLayerValidationFixture< CLTensor, CLAccessor, CLDepthConvertLayer, T, int32_t >
 
template<typename T >
using CLDepthConvertLayerToU8Fixture = DepthConvertLayerValidationFixture< CLTensor, CLAccessor, CLDepthConvertLayer, T, uint8_t >
 
template<typename T >
using CLDepthConvertLayerToU32Fixture = DepthConvertLayerValidationFixture< CLTensor, CLAccessor, CLDepthConvertLayer, T, uint32_t >
 
template<typename T >
using CLDepthConvertLayerToF16Fixture = DepthConvertLayerValidationFixture< CLTensor, CLAccessor, CLDepthConvertLayer, T, half >
 
template<typename T >
using CLDepthConvertLayerToF32Fixture = DepthConvertLayerValidationFixture< CLTensor, CLAccessor, CLDepthConvertLayer, T, float >
 
template<typename T >
using CLDepthToSpaceLayerFixture = DepthToSpaceLayerValidationFixture< CLTensor, CLAccessor, CLDepthToSpaceLayer, T >
 
template<typename T >
using CLDepthwiseConvolutionLayerFixture = DepthwiseConvolutionLayerValidationFixture< CLTensor, CLAccessor, CLDepthwiseConvolutionLayer, T >
 
template<typename T >
using CLDepthwiseSeparableConvolutionLayerFixture = DepthwiseSeparableConvolutionValidationFixture< CLTensor, CLAccessor, CLDepthwiseSeparableConvolutionLayer, T >
 
template<typename T >
using CLDequantizationLayerFixture = DequantizationValidationFixture< CLTensor, CLAccessor, CLDequantizationLayer, T >
 
using CLDerivativeFixture = DerivativeValidationFixture< CLTensor, CLAccessor, CLDerivative, uint8_t, int16_t >
 
template<typename T >
using CLDilateFixture = DilateValidationFixture< CLTensor, CLAccessor, CLDilate, T >
 
template<typename T >
using CLGEMMDilatedConvolutionLayerFixture = ConvolutionValidationFixture< CLTensor, CLAccessor, CLGEMMConvolutionLayer, T >
 
template<typename T >
using CLGEMMDilatedConvolutionLayerQuantizedFixture = ConvolutionValidationQuantizedFixture< CLTensor, CLAccessor, CLGEMMConvolutionLayer, T >
 
template<typename T >
using CLDirectConvolutionLayerFixture = DirectConvolutionValidationFixture< CLTensor, CLAccessor, CLDirectConvolutionLayer, T >
 
template<typename T >
using CLDirectConvolutionValidationWithTensorShapesFixture = DirectConvolutionValidationWithTensorShapesFixture< CLTensor, CLAccessor, CLDirectConvolutionLayer, T >
 
template<typename T >
using CLDirectConvolutionValidationWithTensorShapesQuantizedFixture = DirectConvolutionValidationWithTensorShapesQuantizedFixture< CLTensor, CLAccessor, CLDirectConvolutionLayer, T >
 
template<typename T >
using CLElementwiseMaxFixture = ElementwiseMaxValidationFixture< CLTensor, CLAccessor, CLElementwiseMax, T >
 
template<typename T >
using CLElementwiseMaxQuantizedFixture = ElementwiseMaxValidationQuantizedFixture< CLTensor, CLAccessor, CLElementwiseMax, T >
 
template<typename T >
using CLElementwiseMaxBroadcastFixture = ElementwiseMaxBroadcastValidationFixture< CLTensor, CLAccessor, CLElementwiseMax, T >
 
template<typename T >
using CLElementwiseMinFixture = ElementwiseMinValidationFixture< CLTensor, CLAccessor, CLElementwiseMin, T >
 
template<typename T >
using CLElementwiseMinQuantizedFixture = ElementwiseMinValidationQuantizedFixture< CLTensor, CLAccessor, CLElementwiseMin, T >
 
template<typename T >
using CLElementwiseMinBroadcastFixture = ElementwiseMinBroadcastValidationFixture< CLTensor, CLAccessor, CLElementwiseMin, T >
 
template<typename T >
using CLElementwisePowerFixture = ElementwisePowerValidationFixture< CLTensor, CLAccessor, CLElementwisePower, T >
 
template<typename T >
using CLElementwisePowerBroadcastFixture = ElementwisePowerBroadcastValidationFixture< CLTensor, CLAccessor, CLElementwisePower, T >
 
template<typename T >
using CLElementwiseSquaredDiffFixture = ElementwiseSquaredDiffValidationFixture< CLTensor, CLAccessor, CLElementwiseSquaredDiff, T >
 
template<typename T >
using CLElementwiseSquaredDiffQuantizedFixture = ElementwiseSquaredDiffValidationQuantizedFixture< CLTensor, CLAccessor, CLElementwiseSquaredDiff, T >
 
template<typename T >
using CLElementwiseSquaredDiffBroadcastFixture = ElementwiseSquaredDiffBroadcastValidationFixture< CLTensor, CLAccessor, CLElementwiseSquaredDiff, T >
 
template<typename T >
using CLEqualizeHistogramFixture = EqualizeHistogramValidationFixture< CLTensor, CLAccessor, CLEqualizeHistogram, T >
 
template<typename T >
using CLErodeFixture = ErodeValidationFixture< CLTensor, CLAccessor, CLErode, T >
 
template<typename T >
using CLExpLayerFixture = ExpValidationFixture< CLTensor, CLAccessor, CLExpLayer, T >
 
template<typename T >
using CLFastCornersFixture = FastCornersValidationFixture< CLTensor, CLAccessor, CLKeyPointArray, CLFastCorners, T >
 
template<typename T >
using CLFFT1DFixture = FFTValidationFixture< CLTensor, CLAccessor, CLFFT1D, FFT1DInfo, T >
 
template<typename T >
using CLFFT2DFixture = FFTValidationFixture< CLTensor, CLAccessor, CLFFT2D, FFT2DInfo, T >
 
template<typename T >
using CLFlattenLayerFixture = FlattenLayerValidationFixture< CLTensor, CLAccessor, CLFlattenLayer, T >
 
template<typename T >
using CLFloorFixture = FloorValidationFixture< CLTensor, CLAccessor, CLFloor, T >
 
template<typename T >
using CLFullyConnectedLayerFixture = FullyConnectedLayerValidationFixture< CLTensor, CLAccessor, CLFullyConnectedLayer, T >
 
template<typename T >
using CLFullyConnectedLayerQuantizedFixture = FullyConnectedLayerValidationQuantizedFixture< CLTensor, CLAccessor, CLFullyConnectedLayer, T >
 
template<typename T >
using CLFuseBatchNormalizationConvFixture = FuseBatchNormalizationFixture< CLTensor, CLAccessor, CLFuseBatchNormalization, 4, T >
 
template<typename T >
using CLFuseBatchNormalizationDWCFixture = FuseBatchNormalizationFixture< CLTensor, CLAccessor, CLFuseBatchNormalization, 3, T >
 
template<typename T >
using CLGatherFixture = GatherFixture< CLTensor, CLAccessor, CLGather, T >
 
template<typename T >
using CLGaussian3x3Fixture = Gaussian3x3ValidationFixture< CLTensor, CLAccessor, CLGaussian3x3, T >
 
template<typename T >
using CLGaussian5x5Fixture = Gaussian5x5ValidationFixture< CLTensor, CLAccessor, CLGaussian5x5, T >
 
template<typename T >
using CLGaussianPyramidHalfFixture = GaussianPyramidHalfValidationFixture< CLTensor, CLAccessor, CLGaussianPyramidHalf, T, CLPyramid >
 
template<typename T >
using CLGEMMFixture = GEMMValidationFixture< CLTensor, CLAccessor, CLGEMM, T >
 
template<typename T >
using CLGEMMOutput3DFixture = GEMMValidationFixture< CLTensor, CLAccessor, CLGEMM, T, false, false, true >
 
template<typename T >
using CLGEMMInputOutput3DFixture = GEMMValidationFixture< CLTensor, CLAccessor, CLGEMM, T, false, true, true >
 
using CLGEMMLowpMatrixMultiplyCoreFixture = GEMMLowpMatrixMultiplyCoreValidationFixture< CLTensor, CLAccessor, CLGEMMLowpMatrixMultiplyCore >
 
using CLGEMMLowpMatrixMultiplyCoreFusedOffsetOutputFixture = GEMMLowpMatrixMultiplyCoreFusedOffsetOutputValidationFixture< CLTensor, CLAccessor, CLGEMMLowpMatrixMultiplyCore >
 
using CLGEMMLowpQuantizeDownInt32ToUint8ScaleFixture = GEMMLowpQuantizeDownInt32ToUint8ScaleValidationFixture< CLTensor, CLAccessor, CLGEMMLowpQuantizeDownInt32ToUint8Scale >
 
using CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointFixture = GEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointValidationFixture< CLTensor, CLAccessor, CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint >
 
using CLGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointFixture = GEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointValidationFixture< CLTensor, CLAccessor, CLGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPoint >
 
using CLGEMMLowpMatrixMultiplyNative = CLSynthetizeFunction< CLGEMMLowpMatrixMultiplyNativeKernel >
 
using CLGEMMLowpMatrixMultiplyNativeFixture = GEMMLowpMatrixMultiplyNativeValidationFixture< CLTensor, CLAccessor, CLGEMMLowpMatrixMultiplyNative >
 
using CLGEMMLowpMatrixMultiplyNative3DFixture = GEMMLowpMatrixMultiplyNative3DValidationFixture< CLTensor, CLAccessor, CLGEMMLowpMatrixMultiplyNative >
 
using CLGEMMReshapeLHSMatrix = CLSynthetizeFunction< CLGEMMReshapeLHSMatrixKernel >
 
using CLGEMMReshapeRHSMatrix = CLSynthetizeFunction< CLGEMMReshapeRHSMatrixKernel >
 
using CLGEMMLowpMatrixMultiplyReshaped = CLSynthetizeFunction< CLGEMMLowpMatrixMultiplyReshapedKernel >
 
using CLGEMMLowpMatrixMultiplyReshapedFixture = GEMMLowpMatrixMultiplyReshapedValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeLHSMatrix, CLGEMMReshapeRHSMatrix, CLGEMMLowpMatrixMultiplyReshaped >
 
using CLGEMMLowpMatrixMultiplyReshaped3DFixture = GEMMLowpMatrixMultiplyReshaped3DValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeLHSMatrix, CLGEMMReshapeRHSMatrix, CLGEMMLowpMatrixMultiplyReshaped >
 
using CLGEMMLowpMatrixMultiplyReshapedOnlyRHS = CLSynthetizeFunction< CLGEMMLowpMatrixMultiplyReshapedOnlyRHSKernel >
 
using CLGEMMLowpMatrixMultiplyReshapedOnlyRHSFixture = GEMMLowpMatrixMultiplyReshapedOnlyRHSValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeRHSMatrix, CLGEMMLowpMatrixMultiplyReshapedOnlyRHS >
 
using CLGEMMLowpMatrixMultiplyReshapedOnlyRHS3DFixture = GEMMLowpMatrixMultiplyReshapedOnlyRHS3DValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeRHSMatrix, CLGEMMLowpMatrixMultiplyReshapedOnlyRHS >
 
using CLGEMMMatrixMultiplyNative = CLSynthetizeFunction< CLGEMMMatrixMultiplyKernel >
 
template<typename T >
using CLGEMMMatrixMultiplyNativeFixture = GEMMMatrixMultiplyValidationFixture< CLTensor, CLAccessor, T, CLGEMMMatrixMultiplyNative >
 
template<typename T >
using CLGEMMMatrixMultiplyNative3DFixture = GEMMMatrixMultiply3DValidationFixture< CLTensor, CLAccessor, T, CLGEMMMatrixMultiplyNative >
 
using CLGEMMMatrixMultiplyReshaped = CLSynthetizeFunction< CLGEMMMatrixMultiplyKernel >
 
template<typename T >
using CLGEMMMatrixMultiplyReshapedFixture = GEMMMatrixMultiplyInterleavedTransposedValidationFixture< CLTensor, CLAccessor, T, CLGEMMReshapeLHSMatrix, CLGEMMReshapeRHSMatrix, CLGEMMMatrixMultiplyReshaped >
 
template<typename T >
using CLGEMMMatrixMultiplyReshaped3DFixture = GEMMMatrixMultiplyInterleavedTransposed3DValidationFixture< CLTensor, CLAccessor, T, CLGEMMReshapeLHSMatrix, CLGEMMReshapeRHSMatrix, CLGEMMMatrixMultiplyReshaped >
 
using CLGEMMMatrixMultiplyReshapedOnlyRHS = CLSynthetizeFunction< CLGEMMMatrixMultiplyReshapedOnlyRHSKernel >
 
template<typename T >
using CLGEMMMatrixMultiplyReshapedOnlyRHSFixture = GEMMMatrixMultiplyReshapedOnlyRHSValidationFixture< CLTensor, CLAccessor, T, CLGEMMReshapeRHSMatrix, CLGEMMMatrixMultiplyReshapedOnlyRHS >
 
template<typename T >
using CLGEMMMatrixMultiplyReshapedOnlyRHS3DFixture = GEMMMatrixMultiplyReshapedOnlyRHS3DValidationFixture< CLTensor, CLAccessor, T, CLGEMMReshapeRHSMatrix, CLGEMMMatrixMultiplyReshapedOnlyRHS >
 
template<typename T >
using CLGEMMReshapeLHSMatrixFixture = GEMMReshapeLHSMatrixValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeLHSMatrix, T, false >
 
template<typename T >
using CLGEMMReshapeLHSMatrix3DFixture = GEMMReshapeLHSMatrixValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeLHSMatrix, T, true >
 
template<typename T >
using CLGEMMReshapeRHSMatrixFixture = GEMMReshapeRHSMatrixValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeRHSMatrix, T >
 
template<typename T >
using CLComputeAllAnchorsFixture = ComputeAllAnchorsFixture< CLTensor, CLAccessor, CLComputeAllAnchors, T >
 
template<typename T >
using CLGlobalPoolingLayerFixture = GlobalPoolingLayerValidationFixture< CLTensor, CLAccessor, CLPoolingLayer, T >
 
template<typename T >
using CLHarrisCornersFixture = HarrisCornersValidationFixture< CLTensor, CLAccessor, CLKeyPointArray, CLHarrisCorners, T >
 
template<typename T >
using CLHeightConcatenateLayerFixture = ConcatenateLayerValidationFixture< CLTensor, ICLTensor, CLAccessor, CLConcatenateLayer, T >
 
template<typename T >
using CLHistogramFixture = HistogramValidationFixture< CLTensor, CLAccessor, CLHistogram, T, CLDistribution1D >
 
using CLHOGDescriptorFixture = HOGDescriptorValidationFixture< CLTensor, CLHOG, CLAccessor, CLHOGDescriptor, uint8_t, float >
 
using CLHOGDetectorFixture = HOGDetectorValidationFixture< CLTensor, CLHOG, CLDetectionWindowArray, CLHOGDescriptor, CLAccessor, CLArrayAccessor< DetectionWindow >, CLHOGAccessor, CLHOGDetector, uint8_t, float >
 
using CLHOGMultiDetectionFixture = HOGMultiDetectionValidationFixture< CLTensor, CLHOG, CLMultiHOG, CLDetectionWindowArray, CLSize2DArray, CLAccessor, CLArrayAccessor< Size2D >, CLArrayAccessor< DetectionWindow >, CLHOGAccessor, CLHOGMultiDetection, uint8_t, float >
 
using CLIm2Col = CLSynthetizeFunction< CLIm2ColKernel >
 
template<typename T >
using CLIm2ColFixture = Im2ColValidationFixture< CLTensor, CLAccessor, CLIm2Col, T, true >
 
template<typename T >
using CLIntegralImageFixture = IntegralImageValidationFixture< CLTensor, CLAccessor, CLIntegralImage, T >
 
template<typename T >
using CLL2NormalizeLayerFixture = L2NormalizeLayerValidationFixture< CLTensor, CLAccessor, CLL2NormalizeLayer, T >
 
using CLLaplacianPyramidFixture = LaplacianPyramidValidationFixture< CLTensor, CLAccessor, CLLaplacianPyramid, uint8_t, int16_t, CLPyramid >
 
using CLLaplacianReconstructFixture = LaplacianReconstructValidationFixture< CLTensor, CLAccessor, CLLaplacianReconstruct, CLLaplacianPyramid, int16_t, uint8_t, CLPyramid >
 
template<typename T >
using CLLocallyConnectedFixture = LocallyConnectedValidationFixture< CLTensor, CLAccessor, CLLocallyConnectedLayer, T >
 
template<typename T >
using CLLogLayerFixture = LogValidationFixture< CLTensor, CLAccessor, CLLogLayer, T >
 
template<typename T >
using CLLSTMLayerFixture = LSTMLayerValidationFixture< CLTensor, CLAccessor, CLLSTMLayer, LSTMParams< ICLTensor >, T >
 
template<typename T >
using CLMagnitudeFixture = MagnitudeValidationFixture< CLTensor, CLAccessor, CLMagnitude, T >
 
template<typename T >
using CLMeanStdDevFixture = MeanStdDevValidationFixture< CLTensor, CLAccessor, CLMeanStdDev, T >
 
template<typename T >
using CLMeanStdDevNormalizationLayerFixture = MeanStdDevNormalizationLayerValidationFixture< CLTensor, CLAccessor, CLMeanStdDevNormalizationLayer, T >
 
template<typename T >
using CLMedian3x3Fixture = Median3x3ValidationFixture< CLTensor, CLAccessor, CLMedian3x3, T >
 
template<typename T >
using CLMinMaxLocationFixture = MinMaxLocationValidationFixture< CLTensor, CLAccessor, CLArray< Coordinates2D >, CLArrayAccessor< Coordinates2D >, CLMinMaxLocation, T >
 
template<typename T >
using CLNegLayerFixture = NegValidationFixture< CLTensor, CLAccessor, CLNegLayer, T >
 
template<typename T >
using CLNonLinearFilterFixture = NonLinearFilterValidationFixture< CLTensor, CLAccessor, CLNonLinearFilter, T >
 
template<typename T >
using CLNormalizationLayerFixture = NormalizationValidationFixture< CLTensor, CLAccessor, CLNormalizationLayer, T >
 
template<typename T >
using CLNormalizePlanarYUVLayerFixture = NormalizePlanarYUVLayerValidationFixture< CLTensor, CLAccessor, CLNormalizePlanarYUVLayer, T >
 
template<typename T >
using CLNormalizePlanarYUVLayerQuantizedFixture = NormalizePlanarYUVLayerValidationQuantizedFixture< CLTensor, CLAccessor, CLNormalizePlanarYUVLayer, T >
 
using CLOpticalFlowFixture = OpticalFlowValidationFixture< CLTensor, CLAccessor, CLKeyPointArray, CLArrayAccessor< KeyPoint >, CLOpticalFlow, CLPyramid, CLGaussianPyramidHalf, uint8_t >
 
template<typename T >
using CLPaddingFixture = PaddingFixture< CLTensor, CLAccessor, CLPadLayer, T >
 
template<typename T >
using CLPhaseFixture = PhaseValidationFixture< CLTensor, CLAccessor, CLPhase, T >
 
template<typename T >
using CLPixelWiseMultiplicationToF16Fixture = PixelWiseMultiplicationValidationFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, half_float::half >
 
template<typename T >
using CLPixelWiseMultiplicationToF32Fixture = PixelWiseMultiplicationValidationFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, float >
 
template<typename T >
using CLPixelWiseMultiplicationBroadcastFixture = PixelWiseMultiplicationBroadcastValidationFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, float >
 
template<typename T >
using CLPixelWiseMultiplicationQuantizedFixture = PixelWiseMultiplicationValidationQuantizedFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, T >
 
template<typename T >
using CLPoolingLayerFixture = PoolingLayerValidationFixture< CLTensor, CLAccessor, CLPoolingLayer, T >
 
template<typename T >
using CLSpecialPoolingLayerFixture = SpecialPoolingLayerValidationFixture< CLTensor, CLAccessor, CLPoolingLayer, T >
 
template<typename T >
using CLPReluLayerFixture = PReluLayerValidationFixture< CLTensor, CLAccessor, CLPReluLayer, T >
 
template<typename T >
using CLPReluLayerQuantizedFixture = PReluLayerValidationQuantizedFixture< CLTensor, CLAccessor, CLPReluLayer, T >
 
template<typename T >
using CLPReluLayerBroadcastFixture = PReluLayerBroadcastValidationFixture< CLTensor, CLAccessor, CLPReluLayer, T >
 
template<typename T >
using CLPriorBoxLayerFixture = PriorBoxLayerValidationFixture< CLTensor, CLAccessor, CLPriorBoxLayer, T >
 
template<typename T >
using CLQuantizationLayerFixture = QuantizationValidationFixture< CLTensor, CLAccessor, CLQuantizationLayer, T >
 
template<typename T >
using CLRangeFixture = RangeFixture< CLTensor, CLAccessor, CLRange, T >
 
template<typename T >
using CLReduceMeanFixture = ReduceMeanFixture< CLTensor, CLAccessor, CLReduceMean, T >
 
template<typename T >
using CLReductionOperationFixture = ReductionOperationFixture< CLTensor, CLAccessor, CLReductionOperation, T >
 
template<typename T >
using CLRemapFixture = RemapValidationFixture< CLTensor, CLAccessor, CLRemap, T >
 
template<typename T >
using CLReorgLayerFixture = ReorgLayerValidationFixture< CLTensor, CLAccessor, CLReorgLayer, T >
 
template<typename T >
using CLReshapeLayerFixture = ReshapeLayerValidationFixture< CLTensor, CLAccessor, CLReshapeLayer, T >
 
template<typename T >
using CLReverseFixture = ReverseValidationFixture< CLTensor, CLAccessor, CLReverse, T >
 
template<typename T >
using CLRNNLayerFixture = RNNLayerValidationFixture< CLTensor, CLAccessor, CLRNNLayer, T >
 
template<typename T >
using CLROIAlignLayerFixture = ROIAlignLayerFixture< CLTensor, CLAccessor, CLROIAlignLayer, T >
 
template<typename T >
using CLRoundLayerFixture = RoundValidationFixture< CLTensor, CLAccessor, CLRoundLayer, T >
 
template<typename T >
using CLRsqrtLayerFixture = RsqrtValidationFixture< CLTensor, CLAccessor, CLRsqrtLayer, T >
 
template<typename T >
using CLScaleFixture = ScaleValidationFixture< CLTensor, CLAccessor, CLScale, T >
 
using CLScharr3x3Fixture = ScharrValidationFixture< CLTensor, CLAccessor, CLScharr3x3, uint8_t, int16_t >
 
template<typename T >
using CLSelectFixture = SelectValidationFixture< CLTensor, CLAccessor, CLSelect, T >
 
template<typename T >
using CLSinLayerFixture = SinValidationFixture< CLTensor, CLAccessor, CLSinLayer, T >
 
template<typename T >
using CLSliceFixture = SliceFixture< CLTensor, CLAccessor, CLSlice, T >
 
using CLSobel3x3Fixture = SobelValidationFixture< CLTensor, CLAccessor, CLSobel3x3, uint8_t, int16_t >
 
using CLSobel5x5Fixture = SobelValidationFixture< CLTensor, CLAccessor, CLSobel5x5, uint8_t, int16_t >
 
using CLSobel7x7Fixture = SobelValidationFixture< CLTensor, CLAccessor, CLSobel7x7, uint8_t, int32_t >
 
template<typename T >
using CLSoftmaxLayerFixture = SoftmaxValidationFixture< CLTensor, CLAccessor, CLSoftmaxLayer, T >
 
template<typename T >
using CLSoftmaxLayerQuantizedFixture = SoftmaxValidationQuantizedFixture< CLTensor, CLAccessor, CLSoftmaxLayer, T >
 
template<typename T >
using CLSpaceToBatchLayerFixture = SpaceToBatchLayerValidationFixture< CLTensor, CLAccessor, CLSpaceToBatchLayer, T >
 
template<typename T >
using CLSpaceToDepthLayerFixture = SpaceToDepthLayerValidationFixture< CLTensor, CLAccessor, CLSpaceToDepthLayer, T >
 
template<typename T >
using CLSplitFixture = SplitFixture< CLTensor, ICLTensor, CLAccessor, CLSplit, T >
 
template<typename T >
using CLStackLayerFixture = StackLayerValidationFixture< CLTensor, ICLTensor, CLAccessor, CLStackLayer, T >
 Fixture to use. More...
 
template<typename T >
using CLStridedSliceFixture = StridedSliceFixture< CLTensor, CLAccessor, CLStridedSlice, T >
 
template<typename T >
using CLTableLookupFixture = TableLookupValidationFixture< CLTensor, CLAccessor, CLTableLookup, CLLutAccessor< T >, CLLut, T >
 
template<typename T >
using CLThresholdFixture = ThresholdValidationFixture< CLTensor, CLAccessor, CLThreshold, T >
 
template<typename T >
using CLTileFixture = TileValidationFixture< CLTensor, CLAccessor, CLTile, T >
 
template<typename T >
using CLTransposeFixture = TransposeValidationFixture< CLTensor, CLAccessor, CLTranspose, T >
 
using CLBlobMemoryManagerSimpleWithinFunctionLevelFixture = BlobMemoryManagerSimpleTestCaseFixture< CLTensor, CLAccessor, CLBufferAllocator, CLFullyConnectedLayer >
 
using CLWeightsRetentionFixture = WeightsRetentionReconfigureTestCaseFixture< CLTensor, CLAccessor, CLFullyConnectedLayer >
 
template<typename T >
using CLUnstackFixture = UnstackValidationFixture< CLTensor, ICLTensor, CLAccessor, CLUnstack, T >
 
template<typename T >
using CLUpsampleLayerFixture = UpsampleLayerFixture< CLTensor, CLAccessor, CLUpsampleLayer, T >
 
template<typename T >
using CLWarpAffineFixture = WarpAffineValidationFixture< CLTensor, CLAccessor, CLWarpAffine, T >
 
template<typename T >
using CLWarpPerspectiveFixture = WarpPerspectiveValidationFixture< CLTensor, CLAccessor, CLWarpPerspective, T >
 
using CLWeightsReshape = CLSynthetizeFunction< CLWeightsReshapeKernel >
 
template<typename T >
using CLWeightsReshapeFixture = WeightsReshapeValidationFixture< CLTensor, CLAccessor, CLWeightsReshape, T >
 
template<typename T >
using CLWidthConcatenateLayerFixture = ConcatenateLayerValidationFixture< CLTensor, ICLTensor, CLAccessor, CLConcatenateLayer, T >
 
using CLWinogradInputTransformFixtureFP32 = WinogradInputTransformValidationFixture< CLTensor, CLAccessor, CLWinogradInputTransform, float >
 
using CLWinogradInputTransformFixtureFP16 = WinogradInputTransformValidationFixture< CLTensor, CLAccessor, CLWinogradInputTransform, half >
 
using CLWinogradFilterTransform = CLSynthetizeFunctionWithZeroConstantBorder< CLWinogradFilterTransformKernel, 0 >
 
using CLWinogradFilterTransformFixtureFP32 = WinogradFilterTransformValidationFixture< CLTensor, CLAccessor, CLWinogradFilterTransform, float >
 
using CLWinogradFilterTransformFixtureFP16 = WinogradFilterTransformValidationFixture< CLTensor, CLAccessor, CLWinogradFilterTransform, half >
 
using CLWinogradOutputTransform = CLSynthetizeFunctionWithZeroConstantBorder< CLWinogradOutputTransformKernel, 0 >
 
using CLWinogradOutputTransformFixtureFP32 = WinogradOutputTransformValidationFixture< CLTensor, CLAccessor, CLWinogradOutputTransform, float >
 
using CLWinogradOutputTransformFixtureFP16 = WinogradOutputTransformValidationFixture< CLTensor, CLAccessor, CLWinogradOutputTransform, half >
 
using CLWinogradConvolutionLayerFastMathFixture = WinogradConvolutionLayerFastMathValidationFixture< CLTensor, CLAccessor, CLWinogradConvolutionLayer, float >
 
template<typename T >
using CLYOLOLayerFixture = YOLOValidationFixture< CLTensor, CLAccessor, CLYOLOLayer, T >
 
using CPPNonMaxSuppressionFixture = NMSValidationFixture< Tensor, Accessor, CPPNonMaximumSuppression >
 
template<typename T >
using CPPPermuteFixture = PermuteValidationFixture< Tensor, Accessor, CPPPermute, T >
 
template<typename T >
using GCActivationLayerFixture = ActivationValidationFixture< GCTensor, GCAccessor, GCActivationLayer, T >
 
template<typename T >
using GCArithmeticAdditionFixture = ArithmeticAdditionValidationFixture< GCTensor, GCAccessor, GCArithmeticAddition, T >
 
template<typename T >
using GCBatchNormalizationLayerFixture = BatchNormalizationLayerValidationFixture< GCTensor, GCAccessor, GCBatchNormalizationLayer, T >
 
template<typename T >
using GCConvolutionLayerFixture = ConvolutionValidationFixture< GCTensor, GCAccessor, GCConvolutionLayer, T >
 
template<typename T >
using GCDepthConcatenateLayerFixture = ConcatenateLayerValidationFixture< GCTensor, IGCTensor, GCAccessor, GCConcatenateLayer, T >
 
template<typename T >
using GCDepthwiseConvolutionLayerFixture3x3 = DepthwiseConvolutionLayerValidationFixture< GCTensor, GCAccessor, GCDepthwiseConvolutionLayer3x3, T >
 
template<typename T >
using GCDirectConvolutionLayerFixture = DirectConvolutionValidationFixture< GCTensor, GCAccessor, GCDirectConvolutionLayer, T >
 
template<typename T >
using GCDirectConvolutionLayerTensorShiftFixture = DirectConvolutionValidationTensorShiftFixture< GCTensor, GCAccessor, GCDirectConvolutionLayer, T >
 
template<typename T >
using GCDropoutLayerFixture = DropoutLayerValidationFixture< GCTensor, GCAccessor, GCDropoutLayer, T >
 
template<typename T >
using GCFullyConnectedLayerFixture = FullyConnectedLayerValidationFixture< GCTensor, GCAccessor, GCFullyConnectedLayer, T >
 
template<typename T >
using GCGEMMFixture = GEMMValidationFixture< GCTensor, GCAccessor, GCGEMM, T >
 
template<typename T >
using GCGlobalPoolingLayerFixture = GlobalPoolingLayerValidationFixture< GCTensor, GCAccessor, GCPoolingLayer, T >
 
template<typename T >
using GCNormalizationLayerFixture = NormalizationValidationFixture< GCTensor, GCAccessor, GCNormalizationLayer, T >
 
template<typename T >
using GCNormalizePlanarYUVLayerFixture = NormalizePlanarYUVLayerValidationFixture< GCTensor, GCAccessor, GCNormalizePlanarYUVLayer, T >
 
template<typename T >
using GCPoolingLayerFixture = PoolingLayerValidationFixture< GCTensor, GCAccessor, GCPoolingLayer, T >
 
template<typename T >
using GCScaleFixture = ScaleValidationFixture< GCTensor, GCAccessor, GCScale, T >
 
template<typename T >
using GCSoftmaxLayerFixture = SoftmaxValidationFixture< GCTensor, GCAccessor, GCSoftmaxLayer, T >
 
template<typename T >
using GCTransposeFixture = TransposeValidationFixture< GCTensor, GCAccessor, GCTranspose, T >
 
using GCBlobMemoryManagerSimpleWithinFunctionLevelFixture = BlobMemoryManagerSimpleTestCaseFixture< GCTensor, GCAccessor, GCBufferAllocator, GCFullyConnectedLayer >
 
using GCBlobMemoryManagerReconfigureFixture = BlobMemoryManagerReconfigureTestCaseFixture< GCTensor, GCAccessor, GCBufferAllocator, GCFullyConnectedLayer >
 
using GCBlobMemoryManagerReconfigure2Fixture = BlobMemoryManagerReconfigure2TestCaseFixture< GCTensor, GCAccessor, GCBufferAllocator, GCFullyConnectedLayer, GCSoftmaxLayer >
 
template<typename T >
using NEAbsoluteDifferenceFixture = AbsoluteDifferenceValidationFixture< Tensor, Accessor, NEAbsoluteDifference, T >
 
template<typename T1 >
using NEAccumulateFixture = AccumulateValidationFixture< Tensor, Accessor, NEAccumulate, T1, int16_t >
 
template<typename T1 >
using NEAccumulateWeightedFixture = AccumulateWeightedValidationFixture< Tensor, Accessor, NEAccumulateWeighted, T1, uint8_t >
 
template<typename T1 >
using NEAccumulateSquaredFixture = AccumulateSquaredValidationFixture< Tensor, Accessor, NEAccumulateSquared, T1, int16_t >
 
template<typename T >
using NEActivationLayerFixture = ActivationValidationFixture< Tensor, Accessor, NEActivationLayer, T >
 
template<typename T >
using NEArgMinMaxValidationFixture = ArgMinMaxValidationFixture< Tensor, Accessor, NEArgMinMaxLayer, T >
 
template<typename T >
using NEArithmeticAdditionFixture = ArithmeticAdditionValidationFixture< Tensor, Accessor, NEArithmeticAddition, T >
 
template<typename T >
using NEArithmeticAdditionBroadcastFixture = ArithmeticAdditionBroadcastValidationFixture< Tensor, Accessor, NEArithmeticAddition, T >
 
template<typename T >
using NEArithmeticSubtractionFixture = ArithmeticSubtractionValidationFixture< Tensor, Accessor, NEArithmeticSubtraction, T >
 
template<typename T >
using NEArithmeticSubtractionBroadcastFixture = ArithmeticSubtractionBroadcastValidationFixture< Tensor, Accessor, NEArithmeticSubtraction, T >
 
template<typename T >
using NEBatchConcatenateLayerFixture = ConcatenateLayerValidationFixture< Tensor, ITensor, Accessor, NEConcatenateLayer, T >
 
template<typename T >
using NEBatchNormalizationLayerFixture = BatchNormalizationLayerValidationFixture< Tensor, Accessor, NEBatchNormalizationLayer, T >
 
template<typename T >
using NEBatchToSpaceLayerFixture = BatchToSpaceLayerValidationFixture< Tensor, Accessor, NEBatchToSpaceLayer, T >
 
template<typename T >
using NEBitwiseAndFixture = BitwiseAndValidationFixture< Tensor, Accessor, NEBitwiseAnd, T >
 
template<typename T >
using NEBitwiseNotFixture = BitwiseNotValidationFixture< Tensor, Accessor, NEBitwiseNot, T >
 
template<typename T >
using NEBitwiseOrFixture = BitwiseOrValidationFixture< Tensor, Accessor, NEBitwiseOr, T >
 
template<typename T >
using NEBitwiseXorFixture = BitwiseXorValidationFixture< Tensor, Accessor, NEBitwiseXor, T >
 
template<typename T >
using NEBox3x3Fixture = Box3x3ValidationFixture< Tensor, Accessor, NEBox3x3, T >
 
template<typename T >
using NECannyEdgeFixture = CannyEdgeValidationFixture< Tensor, Accessor, KeyPointArray, NECannyEdge, T >
 
template<typename T >
using NECastToU8Fixture = CastValidationFixture< Tensor, Accessor, NECast, T, uint8_t >
 
template<typename T >
using NECastToU16Fixture = CastValidationFixture< Tensor, Accessor, NECast, T, uint16_t >
 
template<typename T >
using NECastToS16Fixture = CastValidationFixture< Tensor, Accessor, NECast, T, int16_t >
 
template<typename T >
using NECastToU32Fixture = CastValidationFixture< Tensor, Accessor, NECast, T, uint32_t >
 
template<typename T >
using NECastToS32Fixture = CastValidationFixture< Tensor, Accessor, NECast, T, int32_t >
 
template<typename T >
using NECastToF16Fixture = CastValidationFixture< Tensor, Accessor, NECast, T, half >
 
template<typename T >
using NECastToF32Fixture = CastValidationFixture< Tensor, Accessor, NECast, T, float >
 
template<typename T >
using NECastToQASYMM8Fixture = CastValidationFixture< Tensor, Accessor, NECast, T, uint8_t >
 
template<typename T >
using NEChannelExtractFixture = ChannelExtractValidationFixture< MultiImage, Tensor, Accessor, NEChannelExtract, T >
 
template<typename T >
using NEChannelShuffleLayerFixture = ChannelShuffleLayerValidationFixture< Tensor, Accessor, NEChannelShuffleLayer, T >
 
template<typename T >
using NEColorConvertFixture = ColorConvertValidationFixture< MultiImage, Tensor, Accessor, NEColorConvert, T >
 
template<typename T >
using NEComparisonFixture = ComparisonValidationFixture< Tensor, Accessor, NEElementwiseComparison, T >
 
template<typename T >
using NEConvertFullyConnectedWeightsFixture = ConvertFullyConnectedWeightsValidationFixture< Tensor, Accessor, NEConvertFullyConnectedWeights, T >
 
template<typename T >
using NEConvolutionFixture = ConvolutionSquareValidationFixture< Tensor, Accessor, NEConvolution3x3, T >
 
template<typename T >
using NEWinogradConvolutionLayerNoBiasFixture = WinogradConvolutionLayerFastMathValidationFixture< Tensor, Accessor, NEWinogradConvolutionLayer, T, T, false >
 
template<typename T >
using NEGEMMConvolutionLayerFixture = ConvolutionValidationFixture< Tensor, Accessor, NEGEMMConvolutionLayer, T >
 
template<typename T >
using NECopyFixture = CopyFixture< Tensor, Accessor, NECopy, T >
 
template<typename T >
using NECropResizeFixture = CropResizeFixture< Tensor, Accessor, NECropResize, T >
 
template<typename T >
using NEDeconvolutionLayerFixture4x4 = DeconvolutionValidationFixture< Tensor, Accessor, NEDeconvolutionLayer, T, 4, 4 >
 
template<typename T >
using NEDeconvolutionLayerFixture3x3 = DeconvolutionValidationFixture< Tensor, Accessor, NEDeconvolutionLayer, T, 3, 3 >
 
template<typename T >
using NEDeconvolutionLayerFixture1x1 = DeconvolutionValidationFixture< Tensor, Accessor, NEDeconvolutionLayer, T, 1, 1 >
 
template<typename T >
using NEDeconvolutionLayerQuantizedFixture3x3 = DeconvolutionValidationQuantizedFixture< Tensor, Accessor, NEDeconvolutionLayer, T, 3, 3 >
 
template<typename T >
using NEDeconvolutionLayerQuantizedFixture1x1 = DeconvolutionValidationQuantizedFixture< Tensor, Accessor, NEDeconvolutionLayer, T, 1, 1 >
 
template<typename T >
using NEDepthConcatenateLayerFixture = ConcatenateLayerValidationFixture< Tensor, ITensor, Accessor, NEConcatenateLayer, T >
 
template<typename T >
using NEDepthConvertLayerToU16Fixture = DepthConvertLayerValidationFixture< Tensor, Accessor, NEDepthConvertLayer, T, uint16_t >
 
template<typename T >
using NEDepthConvertLayerToS16Fixture = DepthConvertLayerValidationFixture< Tensor, Accessor, NEDepthConvertLayer, T, int16_t >
 
template<typename T >
using NEDepthConvertLayerToS32Fixture = DepthConvertLayerValidationFixture< Tensor, Accessor, NEDepthConvertLayer, T, int32_t >
 
template<typename T >
using NEDepthConvertLayerToU8Fixture = DepthConvertLayerValidationFixture< Tensor, Accessor, NEDepthConvertLayer, T, uint8_t >
 
template<typename T >
using NEDepthConvertLayerToU32Fixture = DepthConvertLayerValidationFixture< Tensor, Accessor, NEDepthConvertLayer, T, uint32_t >
 
template<typename T >
using NEDepthConvertLayerToF16Fixture = DepthConvertLayerValidationFixture< Tensor, Accessor, NEDepthConvertLayer, T, half >
 
template<typename T >
using NEDepthConvertLayerToF32Fixture = DepthConvertLayerValidationFixture< Tensor, Accessor, NEDepthConvertLayer, T, float >
 
template<typename T >
using NEDepthConvertLayerToQASYMM8Fixture = DepthConvertLayerValidationQuantizedFixture< Tensor, Accessor, NEDepthConvertLayer, T, uint8_t >
 
template<typename T >
using NEDepthConvertLayerQuantizedToF16Fixture = DepthConvertLayerValidationQuantizedFixture< Tensor, Accessor, NEDepthConvertLayer, T, half >
 
template<typename T >
using NEDepthConvertLayerQuantizedToF32Fixture = DepthConvertLayerValidationQuantizedFixture< Tensor, Accessor, NEDepthConvertLayer, T, float >
 
template<typename T >
using NEDepthConvertLayerQuantizedToS32Fixture = DepthConvertLayerValidationQuantizedFixture< Tensor, Accessor, NEDepthConvertLayer, T, int32_t >
 
template<typename T >
using NEDepthToSpaceLayerFixture = DepthToSpaceLayerValidationFixture< Tensor, Accessor, NEDepthToSpaceLayer, T >
 
template<typename T >
using NEDepthwiseConvolutionLayerFixture = DepthwiseConvolutionLayerValidationFixture< Tensor, Accessor, NEDepthwiseConvolutionLayer, T >
 
template<typename T >
using NEDepthwiseConvolutionLayerQuantizedFixture = DepthwiseConvolutionLayerValidationQuantizedFixture< Tensor, Accessor, NEDepthwiseConvolutionLayer, T >
 
using NEDepthwiseConvolutionLayerNative = NESynthetizeFunctionWithZeroConstantKernelBorder< NEDepthwiseConvolutionLayerNativeKernel >
 
template<typename T >
using NEDepthwiseConvolutionLayerNativeFixture = DepthwiseConvolutionLayerNativeValidationFixture< Tensor, Accessor, NEDepthwiseConvolutionLayerNative, T >
 
template<typename T >
using NEDepthwiseSeparableConvolutionLayerFixture = DepthwiseSeparableConvolutionValidationFixture< Tensor, Accessor, NEDepthwiseSeparableConvolutionLayer, T >
 
template<typename T >
using NEDequantizationLayerFixture = DequantizationValidationFixture< Tensor, Accessor, NEDequantizationLayer, T >
 
using NEDerivativeFixture = DerivativeValidationFixture< Tensor, Accessor, NEDerivative, uint8_t, int16_t >
 
template<typename T >
using NEDilateFixture = DilateValidationFixture< Tensor, Accessor, NEDilate, T >
 
template<typename T >
using NEGEMMDilatedConvolutionLayerFixture = ConvolutionValidationFixture< Tensor, Accessor, NEConvolutionLayer, T >
 
template<typename T >
using NEDirectConvolutionLayerFixture = DirectConvolutionValidationFixture< Tensor, Accessor, NEDirectConvolutionLayer, T >
 
template<typename T >
using NEAbsLayerFixture = AbsValidationFixture< Tensor, Accessor, NEAbsLayer, T >
 
template<typename T >
using NEElementwiseDivisionFixture = ElementwiseDivisionValidationFixture< Tensor, Accessor, NEElementwiseDivision, T >
 
template<typename T >
using NEElementwiseDivisionBroadcastFixture = ElementwiseDivisionBroadcastValidationFixture< Tensor, Accessor, NEElementwiseDivision, T >
 
template<typename T >
using NEExpLayerFixture = ExpValidationFixture< Tensor, Accessor, NEExpLayer, T >
 
template<typename T >
using NELogLayerFixture = LogValidationFixture< Tensor, Accessor, NELogLayer, T >
 
template<typename T >
using NEElementwiseMaxFixture = ElementwiseMaxValidationFixture< Tensor, Accessor, NEElementwiseMax, T >
 
template<typename T >
using NEElementwiseMaxQuantizedBroadcastFixture = ElementwiseMaxQuantizedBroadcastValidationFixture< Tensor, Accessor, NEElementwiseMax, T >
 
template<typename T >
using NEElementwiseMaxBroadcastFixture = ElementwiseMaxBroadcastValidationFixture< Tensor, Accessor, NEElementwiseMax, T >
 
template<typename T >
using NEElementwiseMinFixture = ElementwiseMinValidationFixture< Tensor, Accessor, NEElementwiseMin, T >
 
template<typename T >
using NEElementwiseMinQuantizedBroadcastFixture = ElementwiseMinQuantizedBroadcastValidationFixture< Tensor, Accessor, NEElementwiseMin, T >
 
template<typename T >
using NEElementwiseMinBroadcastFixture = ElementwiseMinBroadcastValidationFixture< Tensor, Accessor, NEElementwiseMin, T >
 
template<typename T >
using NENegLayerFixture = NegValidationFixture< Tensor, Accessor, NENegLayer, T >
 
template<typename T >
using NEElementwisePowerFixture = ElementwisePowerValidationFixture< Tensor, Accessor, NEElementwisePower, T >
 
template<typename T >
using NEElementwisePowerBroadcastFixture = ElementwisePowerBroadcastValidationFixture< Tensor, Accessor, NEElementwisePower, T >
 
template<typename T >
using NERoundLayerFixture = RoundValidationFixture< Tensor, Accessor, NERoundLayer, T >
 
template<typename T >
using NERsqrtLayerFixture = RsqrtValidationFixture< Tensor, Accessor, NERsqrtLayer, T >
 
template<typename T >
using NESinLayerFixture = SinValidationFixture< Tensor, Accessor, NESinLayer, T >
 
template<typename T >
using NEElementwiseSquaredDiffFixture = ElementwiseSquaredDiffValidationFixture< Tensor, Accessor, NEElementwiseSquaredDiff, T >
 
template<typename T >
using NEElementwiseSquaredDiffQuantizedBroadcastFixture = ElementwiseSquaredDiffQuantizedBroadcastValidationFixture< Tensor, Accessor, NEElementwiseSquaredDiff, T >
 
template<typename T >
using NEElementwiseSquaredDiffBroadcastFixture = ElementwiseSquaredDiffBroadcastValidationFixture< Tensor, Accessor, NEElementwiseSquaredDiff, T >
 
template<typename T >
using NEEqualizeHistogramFixture = EqualizeHistogramValidationFixture< Tensor, Accessor, NEEqualizeHistogram, T >
 
template<typename T >
using NEErodeFixture = ErodeValidationFixture< Tensor, Accessor, NEErode, T >
 
template<typename T >
using NEFastCornersFixture = FastCornersValidationFixture< Tensor, Accessor, KeyPointArray, NEFastCorners, T >
 
template<typename T >
using NEFFT1DFixture = FFTValidationFixture< Tensor, Accessor, NEFFT1D, FFT1DInfo, T >
 
template<typename T >
using NEFFT2DFixture = FFTValidationFixture< Tensor, Accessor, NEFFT2D, FFT2DInfo, T >
 
template<typename T >
using NEFlattenLayerFixture = FlattenLayerValidationFixture< Tensor, Accessor, NEFlattenLayer, T >
 
template<typename T >
using NEFloorFixture = FloorValidationFixture< Tensor, Accessor, NEFloor, T >
 
template<typename T >
using NEFullyConnectedLayerFixture = FullyConnectedLayerValidationFixture< Tensor, Accessor, NEFullyConnectedLayer, T >
 
template<typename T >
using NEFullyConnectedLayerQuantizedFixture = FullyConnectedLayerValidationQuantizedFixture< Tensor, Accessor, NEFullyConnectedLayer, T >
 
template<typename T >
using NEFuseBatchNormalizationConvFixture = FuseBatchNormalizationFixture< Tensor, Accessor, NEFuseBatchNormalization, 4, T >
 
template<typename T >
using NEFuseBatchNormalizationDWCFixture = FuseBatchNormalizationFixture< Tensor, Accessor, NEFuseBatchNormalization, 3, T >
 
template<typename T >
using NEGatherFixture = GatherFixture< Tensor, Accessor, NEGather, T >
 
template<typename T >
using NEGaussian3x3Fixture = Gaussian3x3ValidationFixture< Tensor, Accessor, NEGaussian3x3, T >
 
template<typename T >
using NEGaussian5x5Fixture = Gaussian5x5ValidationFixture< Tensor, Accessor, NEGaussian5x5, T >
 
template<typename T >
using NEGaussianPyramidHalfFixture = GaussianPyramidHalfValidationFixture< Tensor, Accessor, NEGaussianPyramidHalf, T, Pyramid >
 
using NEGEMMTranspose1xW = NESynthetizeFunctionWithZeroConstantBorder< NEGEMMTranspose1xWKernel, 4 >
 
using NEGEMMTranspose1xWFixture = GEMMTranspose1xWValidationFixture< Tensor, Accessor, NEGEMMTranspose1xW, float >
 
using NEGEMMInterleave4x4Fixture = GEMMInterleave4x4ValidationFixture< Tensor, Accessor, NEGEMMInterleave4x4, float >
 
template<typename T >
using NEGEMMFixtureDisabledC = GEMMValidationFixture< Tensor, Accessor, NEGEMM, T, true >
 
using NEGEMMAssemblyFixture_S8 = GEMMLowpAssemblyFixture< Tensor, Accessor, NEGEMMLowpAssemblyMatrixMultiplyCore, int8_t >
 
using NEGEMMAssemblyFixture_U8 = GEMMLowpAssemblyFixture< Tensor, Accessor, NEGEMMLowpAssemblyMatrixMultiplyCore, uint8_t >
 
using NEGEMMLowpMatrixMultiplyCoreFixture = GEMMLowpMatrixMultiplyCoreValidationFixture< Tensor, Accessor, NEGEMMLowpMatrixMultiplyCore >
 
using NEGEMMLowpMatrixMultiplyCoreFusedOffsetOutputFixture = GEMMLowpMatrixMultiplyCoreFusedOffsetOutputValidationFixture< Tensor, Accessor, NEGEMMLowpMatrixMultiplyCore >
 
using NEGEMMLowpQuantizeDownInt32ToUint8ScaleFixture = GEMMLowpQuantizeDownInt32ToUint8ScaleValidationFixture< Tensor, Accessor, NEGEMMLowpQuantizeDownInt32ToUint8Scale >
 
using NEGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointFixture = GEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointValidationFixture< Tensor, Accessor, NEGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint >
 
using NEGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointFixture = GEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointValidationFixture< Tensor, Accessor, NEGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPoint >
 
template<typename T >
using NEGlobalPoolingLayerFixture = GlobalPoolingLayerValidationFixture< Tensor, Accessor, NEPoolingLayer, T >
 
template<typename T >
using NEHarrisCornersFixture = HarrisCornersValidationFixture< Tensor, Accessor, KeyPointArray, NEHarrisCorners, T >
 
template<typename T >
using NEHeightConcatenateLayerFixture = ConcatenateLayerValidationFixture< Tensor, ITensor, Accessor, NEConcatenateLayer, T >
 
template<typename T >
using NEHistogramFixture = HistogramValidationFixture< Tensor, Accessor, NEHistogram, T, Distribution1D >
 
using NEHOGDescriptorFixture = HOGDescriptorValidationFixture< Tensor, HOG, Accessor, NEHOGDescriptor, uint8_t, float >
 
using NEHOGDetectorFixture = HOGDetectorValidationFixture< Tensor, HOG, DetectionWindowArray, NEHOGDescriptor, Accessor, ArrayAccessor< DetectionWindow >, HOGAccessor, NEHOGDetector, uint8_t, float >
 
using NEHOGMultiDetectionFixture = HOGMultiDetectionValidationFixture< Tensor, HOG, MultiHOG, DetectionWindowArray, Size2DArray, Accessor, ArrayAccessor< Size2D >, ArrayAccessor< DetectionWindow >, HOGAccessor, NEHOGMultiDetection, uint8_t, float >
 
template<typename T >
using NEIm2ColFixture = Im2ColValidationFixture< Tensor, Accessor, NEIm2Col, T, false >
 
template<typename T >
using NEIntegralImageFixture = IntegralImageValidationFixture< Tensor, Accessor, NEIntegralImage, T >
 
template<typename T >
using NEL2NormalizeLayerFixture = L2NormalizeLayerValidationFixture< Tensor, Accessor, NEL2NormalizeLayer, T >
 
using NELaplacianPyramidFixture = LaplacianPyramidValidationFixture< Tensor, Accessor, NELaplacianPyramid, uint8_t, int16_t, Pyramid >
 
using NELaplacianReconstructFixture = LaplacianReconstructValidationFixture< Tensor, Accessor, NELaplacianReconstruct, NELaplacianPyramid, int16_t, uint8_t, Pyramid >
 
template<typename T >
using NELocallyConnectedFixture = LocallyConnectedValidationFixture< Tensor, Accessor, NELocallyConnectedLayer, T >
 
template<typename T >
using NELSTMLayerFixture = LSTMLayerValidationFixture< Tensor, Accessor, NELSTMLayer, LSTMParams< ITensor >, T >
 
template<typename T >
using NEMagnitudeFixture = MagnitudeValidationFixture< Tensor, Accessor, NEMagnitude, T >
 
template<typename T >
using NEMeanStdDevFixture = MeanStdDevValidationFixture< Tensor, Accessor, NEMeanStdDev, T >
 
template<typename T >
using NEMeanStdDevNormalizationLayerFixture = MeanStdDevNormalizationLayerValidationFixture< Tensor, Accessor, NEMeanStdDevNormalizationLayer, T >
 
template<typename T >
using NEMedian3x3Fixture = Median3x3ValidationFixture< Tensor, Accessor, NEMedian3x3, T >
 
template<typename T >
using NEMinMaxLocationFixture = MinMaxLocationValidationFixture< Tensor, Accessor, Array< Coordinates2D >, ArrayAccessor< Coordinates2D >, NEMinMaxLocation, T >
 
template<typename T >
using NENonLinearFilterFixture = NonLinearFilterValidationFixture< Tensor, Accessor, NENonLinearFilter, T >
 
template<typename T >
using NENormalizationLayerFixture = NormalizationValidationFixture< Tensor, Accessor, NENormalizationLayer, T >
 
using NEOpticalFlowFixture = OpticalFlowValidationFixture< Tensor, Accessor, KeyPointArray, ArrayAccessor< KeyPoint >, NEOpticalFlow, Pyramid, NEGaussianPyramidHalf, uint8_t >
 
template<typename T >
using NEPaddingFixture = PaddingFixture< Tensor, Accessor, NEPadLayer, T >
 
template<typename T >
using NEPermuteFixture = PermuteValidationFixture< Tensor, Accessor, NEPermute, T >
 
template<typename T >
using NEPhaseFixture = PhaseValidationFixture< Tensor, Accessor, NEPhase, T >
 
using NEPixelWiseMultiplicationQASYMM8Fixture = PixelWiseMultiplicationValidationQuantizedFixture< Tensor, Accessor, NEPixelWiseMultiplication, uint8_t, uint8_t >
 
using NEPixelWiseMultiplicationQSYMM16Fixture = PixelWiseMultiplicationValidationQuantizedFixture< Tensor, Accessor, NEPixelWiseMultiplication, int16_t, int16_t >
 
template<typename T >
using NEPixelWiseMultiplicationToU8Fixture = PixelWiseMultiplicationValidationFixture< Tensor, Accessor, NEPixelWiseMultiplication, T, uint8_t >
 
template<typename T >
using NEPixelWiseMultiplicationToS16Fixture = PixelWiseMultiplicationValidationFixture< Tensor, Accessor, NEPixelWiseMultiplication, T, int16_t >
 
template<typename T >
using NEPixelWiseMultiplicationToF16Fixture = PixelWiseMultiplicationValidationFixture< Tensor, Accessor, NEPixelWiseMultiplication, T, half_float::half >
 
template<typename T >
using NEPixelWiseMultiplicationToF32Fixture = PixelWiseMultiplicationValidationFixture< Tensor, Accessor, NEPixelWiseMultiplication, T, float >
 
template<typename T >
using NEPixelWiseMultiplicationBroadcastFixture = PixelWiseMultiplicationBroadcastValidationFixture< Tensor, Accessor, NEPixelWiseMultiplication, T, float >
 
template<typename T >
using NEPoolingLayerFixture = PoolingLayerValidationFixture< Tensor, Accessor, NEPoolingLayer, T >
 
template<typename T >
using NESpecialPoolingLayerFixture = SpecialPoolingLayerValidationFixture< Tensor, Accessor, NEPoolingLayer, T >
 
template<typename T >
using NEPReluLayerFixture = PReluLayerValidationFixture< Tensor, Accessor, NEPReluLayer, T >
 
template<typename T >
using NEPReluLayerQuantizedFixture = PReluLayerValidationQuantizedFixture< Tensor, Accessor, NEPReluLayer, T >
 
template<typename T >
using NEPReluLayerBroadcastFixture = PReluLayerBroadcastValidationFixture< Tensor, Accessor, NEPReluLayer, T >
 
template<typename T >
using NEPriorBoxLayerFixture = PriorBoxLayerValidationFixture< Tensor, Accessor, NEPriorBoxLayer, T >
 
template<typename T >
using NEQuantizationLayerFixture = QuantizationValidationFixture< Tensor, Accessor, NEQuantizationLayer, T >
 
template<typename T >
using NERangeFixture = RangeFixture< Tensor, Accessor, NERange, T >
 
template<typename T >
using NEReduceMeanFixture = ReduceMeanFixture< Tensor, Accessor, NEReduceMean, T >
 
template<typename T >
using NEReductionOperationFixture = ReductionOperationFixture< Tensor, Accessor, NEReductionOperation, T >
 
template<typename T >
using NERemapFixture = RemapValidationFixture< Tensor, Accessor, NERemap, T >
 
template<typename T >
using NEReorgLayerFixture = ReorgLayerValidationFixture< Tensor, Accessor, NEReorgLayer, T >
 
template<typename T >
using NEReshapeLayerFixture = ReshapeLayerValidationFixture< Tensor, Accessor, NEReshapeLayer, T >
 
template<typename T >
using NEReverseFixture = ReverseValidationFixture< Tensor, Accessor, NEReverse, T >
 
template<typename T >
using NERNNLayerFixture = RNNLayerValidationFixture< Tensor, Accessor, NERNNLayer, T >
 
template<typename T >
using NEScaleFixture = ScaleValidationFixture< Tensor, Accessor, NEScale, T >
 
template<typename T >
using NEScaleQuantizedFixture = ScaleValidationQuantizedFixture< Tensor, Accessor, NEScale, T >
 
using NEScharr3x3Fixture = ScharrValidationFixture< Tensor, Accessor, NEScharr3x3, uint8_t, int16_t >
 
template<typename T >
using NESelectFixture = SelectValidationFixture< Tensor, Accessor, NESelect, T >
 
template<typename T >
using NESliceFixture = SliceFixture< Tensor, Accessor, NESlice, T >
 
using NESobel3x3Fixture = SobelValidationFixture< Tensor, Accessor, NESobel3x3, uint8_t, int16_t >
 
using NESobel5x5Fixture = SobelValidationFixture< Tensor, Accessor, NESobel5x5, uint8_t, int16_t >
 
using NESobel7x7Fixture = SobelValidationFixture< Tensor, Accessor, NESobel7x7, uint8_t, int32_t >
 
template<typename T >
using NESoftmaxLayerFixture = SoftmaxValidationFixture< Tensor, Accessor, NESoftmaxLayer, T >
 
template<typename T >
using NESpaceToBatchLayerFixture = SpaceToBatchLayerValidationFixture< Tensor, Accessor, NESpaceToBatchLayer, T >
 
template<typename T >
using NESpaceToDepthLayerFixture = SpaceToDepthLayerValidationFixture< Tensor, Accessor, NESpaceToDepthLayer, T >
 
template<typename T >
using NESplitFixture = SplitFixture< Tensor, ITensor, Accessor, NESplit, T >
 
template<typename T >
using NEStackLayerFixture = StackLayerValidationFixture< Tensor, ITensor, Accessor, NEStackLayer, T >
 Fixture to use. More...
 
template<typename T >
using NEStridedSliceFixture = StridedSliceFixture< Tensor, Accessor, NEStridedSlice, T >
 
template<typename T >
using NETableLookupFixture = TableLookupValidationFixture< Tensor, Accessor, NETableLookup, LutAccessor< T >, Lut, T >
 
template<typename T >
using ThresholdFixture = ThresholdValidationFixture< Tensor, Accessor, NEThreshold, T >
 
template<typename T >
using NETileFixture = TileValidationFixture< Tensor, Accessor, NETile, T >
 
template<typename T >
using NETransposeFixture = TransposeValidationFixture< Tensor, Accessor, NETranspose, T >
 
template<typename T >
using NEUnstackFixture = UnstackValidationFixture< Tensor, ITensor, Accessor, NEUnstack, T >
 
template<typename T >
using NEUpsampleLayerFixture = UpsampleLayerFixture< Tensor, Accessor, NEUpsampleLayer, T >
 
template<typename T >
using NEUpsampleLayerQuantizedFixture = UpsampleLayerQuantizedFixture< Tensor, Accessor, NEUpsampleLayer, T >
 
template<typename T >
using NEWarpAffineFixture = WarpAffineValidationFixture< Tensor, Accessor, NEWarpAffine, T >
 
template<typename T >
using NEWarpPerspectiveFixture = WarpPerspectiveValidationFixture< Tensor, Accessor, NEWarpPerspective, T >
 
template<typename T >
using NEWidthConcatenateLayerFixture = ConcatenateLayerValidationFixture< Tensor, ITensor, Accessor, NEConcatenateLayer, T >
 
template<typename T >
using NEYOLOLayerFixture = YOLOValidationFixture< Tensor, Accessor, NEYOLOLayer, T >
 

Functions

 FIXTURE_DATA_TEST_CASE (RunSmall, CLAbsLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLAbsLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::F16)))
 
 TEST_SUITE_END () const auto Int16QuantizedActivationFunctionsDataset = ActivationValidationQuantizedFixture<CLTensor, CLAccessor, CLActivationLayer, T>
 Input data sets. More...
 
 combine (datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLAbsLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::F32)))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), AbsoluteDifferenceU8Dataset), shape, data_type0, data_type1, output_data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLAbsoluteDifferenceFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), AbsoluteDifferenceU8Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLAbsoluteDifferenceFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), AbsoluteDifferenceU8Dataset))
 
 combine (datasets::SmallShapes(), AbsoluteDifferenceS16Dataset)
 
 validate (dst.info() ->valid_region(), valid_region)
 
 validate (ref_src1.info() ->padding(), padding)
 
 validate (ref_src2.info() ->padding(), padding)
 
 validate (dst.info() ->padding(), padding)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLAbsoluteDifferenceFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), AbsoluteDifferenceS16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLAbsoluteDifferenceFixture< int16_t >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), AbsoluteDifferenceS16Dataset))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), AccumulateS16Dataset), shape, data_type, output_data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLAccumulateFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), AccumulateS16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLAccumulateFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), AccumulateS16Dataset))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), AccumulateU8Dataset), shape, data_type, output_data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLAccumulateWeightedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), AccumulateU8Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLAccumulateWeightedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), AccumulateU8Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLAccumulateSquaredFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), AccumulateS16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLAccumulateSquaredFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), AccumulateS16Dataset))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), CNNDataTypes), framework::dataset::make("InPlace", { false, true })), shape, data_type, in_place)
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(30U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16, QuantizationInfo(1.f/32768.f, 0)), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16, QuantizationInfo(1.f/32768.f, 0)), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16, QuantizationInfo(1.f/32768.f, 0)), })), framework::dataset::make("ActivationInfo", { ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::TANH), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::TANH), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LOGISTIC), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::SQRT), })), framework::dataset::make("Expected", { false, false, true, true, false, false, true, true, false })), input_info, output_info, act_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLActivationLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ActivationDataset), framework::dataset::make("DataType", DataType::F16)))
 [CLActivationLayerFixture snippet] More...
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLActivationLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ActivationDataset), framework::dataset::make("DataType", DataType::F16)))
 [CLActivationLayer Test snippet] More...
 
 combine (combine(datasets::SmallShapes(), ActivationDataset), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLActivationLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ActivationDataset), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLActivationLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), QuantizedActivationDataset), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLActivationLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), QuantizedActivationDataset), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) })))
 
 combine (combine(combine(datasets::SmallShapes(), QuantizedActivationDataset), framework::dataset::make("DataType", DataType::QSYMM16)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.f/32768.f, 0) })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLActivationLayerQuantizedFixture< int16_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), QuantizedActivationDataset), framework::dataset::make("DataType", DataType::QSYMM16)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.f/32768.f, 0) })))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(27U, 3U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 3U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 16U, 2U), 1, DataType::F32) }), framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(27U, 3U, 1U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 3U, 1U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 1U, 2U), 1, DataType::U32), TensorInfo(TensorShape(32U, 16U, 1U, 2U), 1, DataType::F32) })), framework::dataset::make("Axis", { 4, 0, 2, 0 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MAX, ReductionOperation::ARG_IDX_MAX, ReductionOperation::ARG_IDX_MAX, ReductionOperation::MEAN_SUM })), framework::dataset::make("Expected", { false, false, true, false })), input_info, output_info, axis, operation, expected)
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::F16, DataType::F32 })), shape, data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArgMinMaxValidationFixture< int32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::Small4DShapes(), framework::dataset::make("DataType", DataType::S32)), framework::dataset::make("Axis", { 0, 1, 2, 3 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MIN, ReductionOperation::ARG_IDX_MAX })))
 
 combine (combine(combine(datasets::Small4DShapes(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("Axis", { 0, 1, 2, 3 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MIN, ReductionOperation::ARG_IDX_MAX })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArgMinMaxValidationFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::Large4DShapes(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("Axis", { 0, 1, 2, 3 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MIN, ReductionOperation::ARG_IDX_MAX })))
 
 combine (combine(combine(datasets::Small4DShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("Axis", { 0, 1, 2, 3 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MIN, ReductionOperation::ARG_IDX_MAX })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArgMinMaxValidationFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::Large4DShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("Axis", { 0, 1, 2, 3 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MIN, ReductionOperation::ARG_IDX_MAX })))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("Input1Info", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), }), framework::dataset::make("Input2Info",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, true, false, false, false})), input1_info, input2_info, output_info, expected)
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), shape, policy)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticAdditionFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticAdditionU8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 combine (combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticAdditionFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticAdditionS16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticAdditionFixture< int16_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ArithmeticAdditionS16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), shape, policy)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticAdditionQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), ArithmeticAdditionQASYMM8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f/255.f, 20) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/255.f, 10) })), framework::dataset::make("OutQInfo", { QuantizationInfo(1.f/255.f, 5) })))
 
 combine (datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE }))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticAdditionQuantizedFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), ArithmeticAdditionQSYMM16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("OutQInfo", { QuantizationInfo(5.f/32768.f, 0) })))
 
 combine (combine(datasets::SmallShapes(), ArithmeticAdditionFP16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 combine (datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticAdditionFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticAdditionFP32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticAdditionFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ArithmeticAdditionFP32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLArithmeticAdditionBroadcastFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapesBroadcast(), ArithmeticAdditionFP32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunLargeBroadcast, CLArithmeticAdditionBroadcastFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapesBroadcast(), ArithmeticAdditionFP32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("Input1Info", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), }), framework::dataset::make("Input2Info",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, false, false, false, false})), input1_info, input2_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticDivisionFixture< half >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ArithmeticDivisionFP16Dataset))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, datasets::SmallShapes(), shape)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticDivisionFixture< float >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), ArithmeticDivisionFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticDivisionFixture< float >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), ArithmeticDivisionFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLArithmeticDivisionBroadcastFixture< float >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapesBroadcast(), ArithmeticDivisionFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLargeBroadcast, CLArithmeticDivisionBroadcastFixture< float >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapesBroadcast(), ArithmeticDivisionFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticSubtractionFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticSubtractionU8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticSubtractionFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticSubtractionS16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticSubtractionFixture< int16_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ArithmeticSubtractionS16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticSubtractionQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), ArithmeticSubtractionQASYMM8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f/255.f, 20) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/255.f, 10) })), framework::dataset::make("OutQInfo", { QuantizationInfo(1.f/255.f, 5) })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticSubtractionQuantizedFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), ArithmeticSubtractionQSYMM16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("OutQInfo", { QuantizationInfo(5.f/32768.f, 0) })))
 
 combine (combine(datasets::SmallShapes(), ArithmeticSubtractionFP16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticSubtractionFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticSubtractionFP32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticSubtractionFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ArithmeticSubtractionFP32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLArithmeticSubtractionBroadcastFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapesBroadcast(), ArithmeticSubtractionFP32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 FIXTURE_DATA_TEST_CASE (RunLargeBroadcast, CLArithmeticSubtractionBroadcastFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapesBroadcast(), ArithmeticSubtractionFP32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("InputInfo1", { TensorInfo(TensorShape(23U, 27U, 5U, 4U), 1, DataType::F32), TensorInfo(TensorShape(20U, 27U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(23U, 26U, 4U, 3U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 4U, 3U), 1, DataType::F32), TensorInfo(TensorShape(16U, 27U, 3U, 6U), 1, DataType::F32) }), framework::dataset::make("InputInfo2", { TensorInfo(TensorShape(23U, 27U, 5U, 4U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 3U, 3U), 1, DataType::F32), TensorInfo(TensorShape(16U, 27U, 3U, 6U), 1, DataType::F32) })), framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(23U, 27U, 5U, 4U), 1, DataType::F16), TensorInfo(TensorShape(23U, 12U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(23U, 20U, 4U, 3U), 1, DataType::F32), TensorInfo(TensorShape(16U, 27U, 3U, 12U), 1, DataType::F32) })), framework::dataset::make("Expected", { false, false, false, false, true })), input_info1, input_info2, output_info, expected)
 
 TEST_CASE (Configuration, framework::DatasetMode::ALL)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBatchConcatenateLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(concat(datasets::Small3DShapes(), datasets::Tiny4DShapes()), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("Axis", 3)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLBatchConcatenateLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(concat(datasets::Large3DShapes(), datasets::Small4DShapes()), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("Axis", 3)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBatchConcatenateLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(concat(datasets::Small3DShapes(), datasets::Tiny4DShapes()), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("Axis", 3)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLBatchConcatenateLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::ConcatenateLayerShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("Axis", 3)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBatchConcatenateLayerFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(concat(datasets::Small3DShapes(), datasets::Tiny4DShapes()), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("Axis", 3)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLBatchConcatenateLayerFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::ConcatenateLayerShapes(), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("Axis", 3)))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallRandomBatchNormalizationLayerDataset(), combine(framework::dataset::make("UseBeta", { false, true }), framework::dataset::make("UseGamma", { false, true }))), framework::dataset::make("DataType", { DataType::F16, DataType::F32 })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), shape0, shape1, epsilon, use_gamma, use_beta, dt, data_layout)
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), })), framework::dataset::make("MVBGInfo",{ TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F16), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(5U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), })), framework::dataset::make("ActivationLayerInfo",{ ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.f), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.f), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU, 6.f), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::TANH), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU, 2.f, 6.f), })), framework::dataset::make("Expected", { true, false, false, false, false, false, false})), input_info, output_info, mvbg_info, act_info, expected)
 
 FIXTURE_DATA_TEST_CASE (Random, CLBatchNormalizationLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallRandomBatchNormalizationLayerDataset(), combine(framework::dataset::make("UseBeta", { false, true }), framework::dataset::make("UseGamma", { false, true }))), act_infos), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 combine (combine(combine(combine(datasets::SmallRandomBatchNormalizationLayerDataset(), combine(framework::dataset::make("UseBeta", { false, true }), framework::dataset::make("UseGamma", { false, true }))), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.f))), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 zip (zip(framework::dataset::make("Weights", { TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U, 1U), 1, DataType::F32), }), framework::dataset::make("MVBGInfo",{ TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F16), TensorInfo(TensorShape(5U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, false, false}))
 
 ARM_COMPUTE_EXPECT (has_error==expected, framework::LogLevel::ERRORS)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBatchNormalizationLayerFusionFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallConvolutionLayerReducedDataset(), common_fusion_dataset), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLBatchNormalizationLayerFusionFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::SmallConvolutionLayerDataset(), common_fusion_dataset), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(16U, 8U, 2U, 16U), 1, DataType::F32), TensorInfo(TensorShape(16U, 8U, 2U, 16U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U, 2U, 4U), 1, DataType::F32), }), framework::dataset::make("BlockShapeInfo",{ TensorInfo(TensorShape(2U, 2U), 1, DataType::S32), TensorInfo(TensorShape(2U, 4U), 1, DataType::S32), TensorInfo(TensorShape(4U, 2U), 1, DataType::S32), TensorInfo(TensorShape(2U, 2U), 1, DataType::S32), TensorInfo(TensorShape(2U, 2U), 1, DataType::F16), TensorInfo(TensorShape(2U, 2U), 1, DataType::S32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(64U, 16U, 2U, 1U), 1, DataType::F32), TensorInfo(TensorShape(32U, 32U, 2U, 1U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F16), TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, true, true, false, false, false})), input_info, block_shape_info, output_info, expected)
 
 DATA_TEST_CASE (ValidateStatic, framework::DatasetMode::ALL, zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(16U, 8U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(16U, 8U, 2U, 16U), 1, DataType::F32), TensorInfo(TensorShape(16U, 8U, 2U, 16U), 1, DataType::F32), TensorInfo(TensorShape(16U, 8U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(16U, 8U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 2U, 4U, 4U), 1, DataType::F32), }), framework::dataset::make("BlockShapeX", { 2, 4, 2, 2, 2, 2 })), framework::dataset::make("BlockShapeY", { 2, 2, 4, 2, -2, 2 })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 16U, 2U, 1U), 1, DataType::F32), TensorInfo(TensorShape(64U, 16U, 2U, 1U), 1, DataType::F32), TensorInfo(TensorShape(32U, 32U, 2U, 1U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 2U, 1U), 1, DataType::F16), TensorInfo(TensorShape(32U, 16U, 2U, 1U), 1, DataType::F32), TensorInfo(TensorShape(32U, 8U, 2U, 1U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, true, true, false, false, false})), input_info, block_shape_x, block_shape_y, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBatchToSpaceLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallBatchToSpaceLayerDataset(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLBatchToSpaceLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeBatchToSpaceLayerDataset(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBatchToSpaceLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallBatchToSpaceLayerDataset(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLBatchToSpaceLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeBatchToSpaceLayerDataset(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)), shape, data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBitwiseAndFixture< uint8_t >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBitwiseNotFixture< uint8_t >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBitwiseOrFixture< uint8_t >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBitwiseXorFixture< uint8_t >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(framework::dataset::make("BoxesInfo", { TensorInfo(TensorShape(4U, 128U), 1, DataType::F32), TensorInfo(TensorShape(5U, 128U), 1, DataType::F32), TensorInfo(TensorShape(4U, 128U), 1, DataType::F16), TensorInfo(TensorShape(4U, 128U), 1, DataType::F32), TensorInfo(TensorShape(4U, 128U), 1, DataType::F32), TensorInfo(TensorShape(4U, 128U), 1, DataType::F32)}), framework::dataset::make("PredBoxesInfo",{ TensorInfo(TensorShape(128U, 128U), 1, DataType::F32), TensorInfo(TensorShape(128U, 128U), 1, DataType::F32), TensorInfo(TensorShape(127U, 128U), 1, DataType::F32), TensorInfo(TensorShape(128U, 100U), 1, DataType::F32), TensorInfo(TensorShape(128U, 100U), 1, DataType::F32), TensorInfo(TensorShape(128U, 128U), 1, DataType::F32)})), framework::dataset::make("DeltasInfo", { TensorInfo(TensorShape(128U, 128U), 1, DataType::F32), TensorInfo(TensorShape(128U, 128U), 1, DataType::F32), TensorInfo(TensorShape(127U, 128U), 1, DataType::F32), TensorInfo(TensorShape(128U, 100U), 1, DataType::F32), TensorInfo(TensorShape(128U, 128U), 1, DataType::F32), TensorInfo(TensorShape(128U, 128U), 1, DataType::F32)})), framework::dataset::make("BoundingBoxTransofmInfo", { BoundingBoxTransformInfo(800.f, 600.f, 1.f), BoundingBoxTransformInfo(800.f, 600.f, 1.f), BoundingBoxTransformInfo(800.f, 600.f, 1.f), BoundingBoxTransformInfo(800.f, 600.f, 1.f), BoundingBoxTransformInfo(800.f, 600.f, 0.f)})), framework::dataset::make("Expected", { true, false, false, false, false, false})), boxes_info, pred_boxes_info, deltas_info, bbox_info, expected)
 
 FIXTURE_DATA_TEST_CASE (BoundingBox, CLBoundingBoxTransformFixture< float >, framework::DatasetMode::ALL, combine(combine(DeltaDataset, BboxInfoDataset), framework::dataset::make("DataType", { DataType::F32 })))
 
 combine (combine(DeltaDataset, BboxInfoDataset), framework::dataset::make("DataType", { DataType::F16 })))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()), shape, data_type, border_mode)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLBox3x3Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLBox3x3Fixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(combine(datasets::Small2DShapes(), data), framework::dataset::make("Format", Format::U8)), shape, gradient_size, normalization, border_mode, format)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCannyEdgeFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallImageFiles(), data), framework::dataset::make("Format", Format::U8)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLCannyEdgeFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeImageFiles(), data), framework::dataset::make("Format", Format::U8)))
 
 TEST_SUITE (U8_to_S8) DATA_TEST_CASE(Configuration
 
 combine (datasets::SmallShapes(), datasets::ConvertPolicies())
 
 validate (src.info() ->padding(), padding)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS8Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU8toS8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU16Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU8toU16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS16Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU8toS16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU32Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU8toU32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS32Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU8toS32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF16Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU8toF16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF32Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU8toF32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU8Fixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS8toU8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU16Fixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS8toU16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS16Fixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS8toS16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU32Fixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS8toU32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS32Fixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS8toS32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF16Fixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS8toF16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF32Fixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS8toF32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU8Fixture< uint16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU16toU8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS8Fixture< uint16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU16toS8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS16Fixture< uint16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU16toS16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU32Fixture< uint16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU16toU32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS32Fixture< uint16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU16toS32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF16Fixture< uint16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU16toF16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF32Fixture< uint16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU16toF32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU8Fixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS16toU8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS8Fixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS16toS8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU16Fixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS16toU16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU32Fixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS16toU32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS32Fixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS16toS32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF16Fixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS16toF16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF32Fixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS16toF32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU8Fixture< uint32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU32toU8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS8Fixture< uint32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU32toS8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU16Fixture< uint32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU32toU16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS16Fixture< uint32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU32toS16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS32Fixture< uint32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU32toS32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF16Fixture< uint32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU32toF16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF32Fixture< uint32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastU32toF32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU8Fixture< int32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS32toU8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS8Fixture< int32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS32toS8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU16Fixture< int32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS32toU16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS16Fixture< int32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS32toS16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU32Fixture< int32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS32toU32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF16Fixture< int32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS32toF16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF32Fixture< int32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastS32toF32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU8Fixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF16toU8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS8Fixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF16toS8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU16Fixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF16toU16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS16Fixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF16toS16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU32Fixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF16toU32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS32Fixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF16toS32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF32Fixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF16toF32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU8Fixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF32toU8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS8Fixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF32toS8Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU16Fixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF32toU16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS16Fixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF32toS16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToU32Fixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF32toU32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToS32Fixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF32toS32Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCastToF16Fixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), CastF32toF16Dataset), datasets::ConvertPolicies()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLChannelCombineFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), framework::dataset::make("FormatType", { Format::RGB888, Format::RGBA8888 })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLChannelCombineFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), framework::dataset::make("FormatType", { Format::RGB888, Format::RGBA8888 })))
 
 combine (datasets::Small2DShapes(), framework::dataset::make("FormatType", { Format::YUYV422, Format::UYVY422 })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLChannelCombineFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), framework::dataset::make("FormatType", { Format::YUYV422, Format::UYVY422 })))
 
 combine (datasets::Small2DShapes(), framework::dataset::make("FormatType", { Format::NV12, Format::NV21, Format::IYUV, Format::YUV444 })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLChannelCombineFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), framework::dataset::make("FormatType", { Format::NV12, Format::NV21, Format::IYUV, Format::YUV444 })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLChannelExtractFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), ChannelExtractRGBADataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLChannelExtractFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ChannelExtractRGBADataset))
 
 combine (datasets::Small2DShapes(), ChannelExtractYUVDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLChannelExtractFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ChannelExtractYUVDataset))
 
 combine (datasets::Small2DShapes(), ChannelExtractYUVPlanarDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLChannelExtractFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ChannelExtractYUVPlanarDataset))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::U8), TensorInfo(TensorShape(4U, 5U, 4U), 1, DataType::F32), TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(4U, 4U, 4U), 1, DataType::F32), })), framework::dataset::make("NumGroups",{ 1, 2, 2, 4, 3, 2, })), framework::dataset::make("Expected", { false, false, false, false, false, true})), input_info, output_info, num_groups, expected)
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallRandomChannelShuffleLayerDataset(), framework::dataset::make("DataType", { DataType::S8, DataType::U8, DataType::S16, DataType::U16, DataType::U32, DataType::S32, DataType::F16, DataType::F32 })), shape, num_groups, data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLChannelShuffleLayerFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallRandomChannelShuffleLayerDataset(), framework::dataset::make("DataType", DataType::U8)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLChannelShuffleLayerFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeRandomChannelShuffleLayerDataset(), framework::dataset::make("DataType", DataType::U8)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLChannelShuffleLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallRandomChannelShuffleLayerDataset(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLChannelShuffleLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeRandomChannelShuffleLayerDataset(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLChannelShuffleLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallRandomChannelShuffleLayerDataset(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLChannelShuffleLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeRandomChannelShuffleLayerDataset(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(10U, 12U, 1U, 2U), 1, DataType::S64), TensorInfo(TensorShape(10U, 12U, 1U, 2U), 1, DataType::F32), TensorInfo(TensorShape(10U, 12U, 1U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 12U, 4U, 2U), 1, DataType::F32), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(3U, 4U, 10U, 2U), 1, DataType::F16), TensorInfo(TensorShape(3U, 4U, 10U, 2U), 1, DataType::F16), TensorInfo(TensorShape(3U, 3U, 10U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 4U, 12U, 2U), 1, DataType::F32), })), framework::dataset::make("ConvolvedWidth", { 3, 3, 3, 3 })), framework::dataset::make("ConvolvedHeight", { 4, 4, 4, 4 })), framework::dataset::make("NumGroups", { 1, 1, 1, 4 })), framework::dataset::make("Expected", { false, false, false, true })), input_info, output_info, convolved_width, convolved_height, num_groups, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCol2ImFixture< float >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLCol2ImFixture< float >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCol2ImFixture< half >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLCol2ImFixture< half >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCol2ImFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::QASYMM8)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLCol2ImFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGroupedCol2ImLayerDataset(), framework::dataset::make("DataType", DataType::QASYMM8)))
 
 DATA_TEST_CASE (RGBA, framework::DatasetMode::ALL, combine(datasets::Small2DShapes(), ColorConvert_RGBA_to_RGB), shape, src_format, dst_format)
 
 DATA_TEST_CASE (RGB, framework::DatasetMode::ALL, combine(datasets::Small2DShapes(), ColorConvert_RGB_to_RGBA), shape, src_format, dst_format)
 
 DATA_TEST_CASE (RGBtoU8, framework::DatasetMode::ALL, combine(datasets::Small2DShapes(), ColorConvert_RGB_to_U8), shape, src_format, dst_format)
 
 DATA_TEST_CASE (YUV, framework::DatasetMode::ALL, combine(datasets::Small2DShapes(), ColorConvert_YUYV_to_RGBDataset), shape, src_format, dst_format)
 
 DATA_TEST_CASE (YUVPlanar, framework::DatasetMode::ALL, combine(datasets::Small2DShapes(), ColorConvert_YUVPlanar_to_RGBDataset), shape, src_format, dst_format)
 
 DATA_TEST_CASE (NV, framework::DatasetMode::ALL, combine(datasets::Small2DShapes(), ColorConvert_RGBDataset_to_NVDataset), shape, src_format, dst_format)
 
 DATA_TEST_CASE (YUYVtoNV, framework::DatasetMode::ALL, combine(datasets::Small2DShapes(), ColorConvert_YUYVDataset_to_NVDataset), shape, src_format, dst_format)
 
 DATA_TEST_CASE (NVtoYUV, framework::DatasetMode::ALL, combine(datasets::Small2DShapes(), ColorConvert_NVDataset_to_YUVDataset), shape, src_format, dst_format)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLColorConvertFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), ColorConvert_RGBA_to_RGB))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLColorConvertFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ColorConvert_RGBA_to_RGB))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLColorConvertFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), ColorConvert_RGB_to_RGBA))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLColorConvertFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ColorConvert_RGB_to_RGBA))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLColorConvertFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), ColorConvert_RGB_to_U8))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLColorConvertFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ColorConvert_RGB_to_U8))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLColorConvertFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), ColorConvert_YUYV_to_RGBDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLColorConvertFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ColorConvert_YUYV_to_RGBDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLColorConvertFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), ColorConvert_YUVPlanar_to_RGBDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLColorConvertFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ColorConvert_YUVPlanar_to_RGBDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLColorConvertFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), ColorConvert_RGBDataset_to_NVDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLColorConvertFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ColorConvert_RGBDataset_to_NVDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLColorConvertFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), ColorConvert_YUYVDataset_to_NVDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLColorConvertFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ColorConvert_YUYVDataset_to_NVDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLColorConvertFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), ColorConvert_NVDataset_to_YUVDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLColorConvertFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), ColorConvert_NVDataset_to_YUVDataset))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("Input1Info", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), }), framework::dataset::make("Input2Info",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), })), framework::dataset::make("Expected", { false, false, false, false, true})), input1_info, input2_info, output_info, expected)
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, configure_dataset, shape, data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLComparisonFixture< half >, framework::DatasetMode::PRECOMMIT, combine(run_small_dataset, framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLComparisonFixture< half >, framework::DatasetMode::NIGHTLY, combine(run_large_dataset, framework::dataset::make("DataType", DataType::F16)))
 
 combine (run_small_dataset, framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLComparisonFixture< float >, framework::DatasetMode::NIGHTLY, combine(run_large_dataset, framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLComparisonQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(run_small_dataset, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f/255.f, 20) })), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255.f, 10) })))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(27U, 42U), 1, DataType::F32), TensorInfo(TensorShape(32U, 42U), 1, DataType::F32), TensorInfo(TensorShape(27U, 42U), 1, DataType::F32), TensorInfo(TensorShape(27U, 42U), 1, DataType::F32), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(27U, 42U), 1, DataType::F16), TensorInfo(TensorShape(32U, 42U), 1, DataType::F32), TensorInfo(TensorShape(32U, 42U), 1, DataType::F32), TensorInfo(TensorShape(32U, 42U), 1, DataType::F32), })), framework::dataset::make("OriginalInput", { TensorShape(7U, 3U, 2U), TensorShape(7U, 3U, 2U), TensorShape(7U, 3U, 2U), TensorShape(7U, 3U, 2U), })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NCHW, DataLayout::NCHW, DataLayout::UNKNOWN, })), framework::dataset::make("Expected", { false, true, false, false})), input_info, output_info, original_input_shape, data_layout, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLConvertFullyConnectedWeightsFixture< float >, framework::DatasetMode::ALL, combine(datasets::Tiny3DShapes(), combine(params, framework::dataset::make("DataType", DataType::F32))))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLConvertFullyConnectedWeightsFixture< float >, framework::DatasetMode::NIGHTLY, combine(datasets::Large3DShapes(), combine(params, framework::dataset::make("DataType", DataType::F32))))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLConvertFullyConnectedWeightsFixture< half >, framework::DatasetMode::ALL, combine(datasets::Tiny3DShapes(), combine(params, framework::dataset::make("DataType", DataType::F16))))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLConvertFullyConnectedWeightsFixture< half >, framework::DatasetMode::NIGHTLY, combine(datasets::Large3DShapes(), combine(params, framework::dataset::make("DataType", DataType::F16))))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLConvertFullyConnectedWeightsFixture< uint8_t >, framework::DatasetMode::ALL, combine(datasets::Tiny3DShapes(), combine(params, framework::dataset::make("DataType", DataType::QASYMM8))))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLConvertFullyConnectedWeightsFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large3DShapes(), combine(params, framework::dataset::make("DataType", DataType::QASYMM8))))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), datasets::BorderModes()), framework::dataset::make("filter_size", { 3 })), shape, output_data_type, border_mode, filter_size)
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLConvolutionFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()), framework::dataset::make("filter_size", { 3 })))
 
 combine (combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::S16)), datasets::BorderModes()), framework::dataset::make("filter_size", { 3 })))
 
 combine (combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), datasets::BorderModes()), framework::dataset::make("filter_size", { 5 }))
 
 ARM_COMPUTE_EXPECT (src.info() ->is_resizable(), framework::LogLevel::ERRORS)
 
 ARM_COMPUTE_EXPECT (dst.info() ->is_resizable(), framework::LogLevel::ERRORS)
 
convolution configure & src (), 0, border_mode
 
 validate (dst.info() ->valid_region(), dst_valid_region)
 
PaddingCalculator calculator (shape.x(), 8)
 
calculator set_border_size (2)
 
calculator set_border_mode (border_mode)
 
calculator set_accessed_elements (16)
 
calculator set_access_offset (-2)
 
 validate (src.info() ->padding(), src_padding)
 
 validate (dst.info() ->padding(), dst_padding)
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLConvolutionFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()), framework::dataset::make("filter_size", { 5 })))
 
 combine (combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::S16)), datasets::BorderModes()), framework::dataset::make("filter_size", { 5 })))
 
 combine (combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), datasets::BorderModes()), framework::dataset::make("filter_size", { 7 }))
 
calculator set_border_size (3)
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLConvolutionFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()), framework::dataset::make("filter_size", { 7 })))
 
 combine (combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::S16)), datasets::BorderModes()), framework::dataset::make("filter_size", { 7 })))
 
 combine (combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), datasets::BorderModes()), framework::dataset::make("filter_size", { 9 }))
 
calculator set_border_size (4)
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLConvolutionFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()), framework::dataset::make("filter_size", { 9 })))
 
 combine (combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::S16)), datasets::BorderModes()), framework::dataset::make("filter_size", { 9 })))
 
 combine (combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), datasets::BorderModes()), framework::dataset::make("filter_width", { 3, 5, 7, 9 })), framework::dataset::make("filter_height", { 3, 5, 7, 9 }))
 
std::vector< int16_t > conv (filter_width *filter_height)
 
calculator set_border_size (filter_width/2)
 
calculator set_access_offset (-(filter_width/2))
 
calculator set_border_size (filter_height/2)
 
calculator set_access_offset (-(filter_height/2))
 
 validate (src.info() ->padding(), width_padding, height_padding)
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLConvolutionFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()), framework::dataset::make("filter_width", { 3, 5, 7, 9 })), framework::dataset::make("filter_height", { 3, 5, 7, 9 })))
 
 combine (combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", DataType::S16)), datasets::BorderModes()), framework::dataset::make("filter_width", { 3, 5, 7, 9 })), framework::dataset::make("filter_height", { 3, 5, 7, 9 })))
 
 DATA_TEST_CASE (ValidateConvolutionMethod, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(17U, 31U, 2U), 1, DataType::F32), TensorInfo(TensorShape(17U, 31U, 2U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 5U, 4U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 31U, 4U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U, 1U), 1, DataType::F32), TensorInfo(TensorShape(33U, 27U, 7U, 4U), 1, DataType::F32), TensorInfo(TensorShape(17U, 31U, 32U), 1, DataType::F32), TensorInfo(TensorShape(17U, 31U, 2U), 1, DataType::F32) }), framework::dataset::make("WeightsInfo", { TensorInfo(TensorShape(5U, 5U, 2U, 19U), 1, DataType::F32), TensorInfo(TensorShape(5U, 5U, 2U, 19U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 5U, 21U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 31U, 21U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 5U, 21U), 1, DataType::F32), TensorInfo(TensorShape(5U, 5U, 7U, 16U), 1, DataType::F16), TensorInfo(TensorShape(5U, 5U, 32U, 19U), 1, DataType::F32), TensorInfo(TensorShape(5U, 5U, 2U, 19U), 1, DataType::F32) })), framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(15U, 15U, 19U), 1, DataType::F32), TensorInfo(TensorShape(15U, 15U, 19U), 1, DataType::F32), TensorInfo(TensorShape(21U, 25U, 21U, 4U), 1, DataType::F32), TensorInfo(TensorShape(21U, 25U, 21U, 4U), 1, DataType::F32), TensorInfo(TensorShape(11U, 25U, 21U), 1, DataType::F32), TensorInfo(TensorShape(11U, 12U, 16U, 4U), 1, DataType::F32), TensorInfo(TensorShape(17U, 31U, 19U), 1, DataType::F32), TensorInfo(TensorShape(17U, 31U, 19U), 1, DataType::F32) })), framework::dataset::make("ConvInfo", { PadStrideInfo(1, 2, 1, 1), PadStrideInfo(1, 2, 1, 1), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(2, 1, 0, 0), PadStrideInfo(3, 2, 1, 0), PadStrideInfo(1, 1, 2, 2), PadStrideInfo(1, 1, 2, 2) })), framework::dataset::make("GpuTarget", { GPUTarget::BIFROST, GPUTarget::MIDGARD, GPUTarget::G71, GPUTarget::G71, GPUTarget::MIDGARD, GPUTarget::BIFROST, GPUTarget::BIFROST, GPUTarget::BIFROST })), framework::dataset::make("Dilation", { Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(2U, 1U), })), framework::dataset::make("EnableFastMath", { false, false, false, false, false, false, true, true })), framework::dataset::make("Expected",{ ConvolutionMethod::GEMM, ConvolutionMethod::GEMM, ConvolutionMethod::GEMM, ConvolutionMethod::WINOGRAD, ConvolutionMethod::GEMM, ConvolutionMethod::GEMM, ConvolutionMethod::WINOGRAD, ConvolutionMethod::GEMM, })), input_info, weights_info, output_info, conv_info, gpu_target, dilation, enable_fast_math, expected)
 
 combine (combine(datasets::SmallConvolutionLayerDataset(), CNNDataTypes), ActivationFunctionsDataset)
 
 ARM_COMPUTE_EXPECT (weights.info() ->is_resizable(), framework::LogLevel::ERRORS)
 
 ARM_COMPUTE_EXPECT (bias.info() ->is_resizable(), framework::LogLevel::ERRORS)
 
 validate (src.info() ->valid_region(), src_valid_region)
 
 validate (weights.info() ->valid_region(), weights_valid_region)
 
 validate (bias.info() ->valid_region(), bias_valid_region)
 
 ARM_COMPUTE_EXPECT (src.info() ->quantization_info()==src_quantization_info, framework::LogLevel::ERRORS)
 
 ARM_COMPUTE_EXPECT (weights.info() ->quantization_info()==weights_quantization_info, framework::LogLevel::ERRORS)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMConvolutionLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallConvolutionLayerReducedDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsSmallDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(framework::dataset::concat(datasets::SmallConvolutionLayerDataset(), datasets::LargeConvolutionLayerDataset()), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(datasets::SmallConvolutionLayerReducedDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsSmallDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(framework::dataset::concat(datasets::SmallConvolutionLayerDataset(), datasets::LargeConvolutionLayerDataset()), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallConvolutionLayerReducedDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), QuantizationData), QuantizedActivationFunctionsSmallDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(framework::dataset::concat(datasets::SmallConvolutionLayerDataset(), datasets::LargeConvolutionLayerDataset()), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), QuantizationData), QuantizedActivationFunctionsDataset))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallGroupedConvolutionLayerDataset(), GroupedCNNDataTypes), ActivationFunctionsDataset), input_shape, weights_shape, bias_shape, output_shape, info, dilation, data_type, act_info)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMGroupedConvolutionLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallGroupedConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW })), ActivationFunctionsSmallDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMGroupedConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(framework::dataset::concat(datasets::SmallGroupedConvolutionLayerDataset(), datasets::LargeGroupedConvolutionLayerDataset()), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW })), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(datasets::SmallGroupedConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW })), ActivationFunctionsSmallDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMGroupedConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(framework::dataset::concat(datasets::SmallGroupedConvolutionLayerDataset(), datasets::LargeGroupedConvolutionLayerDataset()), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW })), ActivationFunctionsDataset))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(14U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 32U, 2U), 1, DataType::U8), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16), TensorInfo(TensorShape(32U, 11U, 2U), 1, DataType::U8), TensorInfo(TensorShape(14U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 32U, 2U), 1, DataType::U8), })), framework::dataset::make("Expected", { false, false, false, true })), input_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCopyFixture< float >, framework::DatasetMode::ALL, combine(zip(datasets::SmallShapes(), datasets::SmallShapes()), framework::dataset::make("DataType", DataType::F32)))
 
 combine (zip(datasets::SmallShapes(), datasets::SmallShapes()), framework::dataset::make("DataType", DataType::U8)))
 
 combine (zip(datasets::SmallShapes(), datasets::SmallShapes()), framework::dataset::make("DataType", DataType::U16)))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(15U, 30U, 40U, 10U), 1, DataType::S32), TensorInfo(TensorShape(15U, 30U, 40U, 10U), 1, DataType::U8), TensorInfo(TensorShape(15U, 30U, 40U, 10U), 1, DataType::S32), TensorInfo(TensorShape(15U, 30U, 40U, 10U), 1, DataType::S32), TensorInfo(TensorShape(15U, 30U, 40U, 10U), 1, DataType::S32), TensorInfo(TensorShape(15U, 30U, 40U, 10U), 1, DataType::S32), TensorInfo(TensorShape(15U, 30U, 40U, 10U), 1, DataType::S32), }), framework::dataset::make("BoxesInfo",{ TensorInfo(TensorShape(4, 20), 1, DataType::F32), TensorInfo(TensorShape(4, 20), 1, DataType::F32), TensorInfo(TensorShape(4, 20), 1, DataType::F32), TensorInfo(TensorShape(4, 20), 1, DataType::F32), TensorInfo(TensorShape(4, 20), 1, DataType::F32), TensorInfo(TensorShape(4, 20), 1, DataType::F32), TensorInfo(TensorShape(3, 20), 1, DataType::F32), })), framework::dataset::make("BoxIndInfo",{ TensorInfo(TensorShape(20), 1, DataType::S32), TensorInfo(TensorShape(20), 1, DataType::S32), TensorInfo(TensorShape(10), 1, DataType::S32), TensorInfo(TensorShape(20), 1, DataType::S32), TensorInfo(TensorShape(20), 1, DataType::S32), TensorInfo(TensorShape(20), 1, DataType::S32), TensorInfo(TensorShape(20), 1, DataType::S32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(15U, 5, 5, 20U), 1, DataType::F32), TensorInfo(TensorShape(15U, 5, 5, 20U), 1, DataType::F32), TensorInfo(TensorShape(15U, 5, 5, 20U), 1, DataType::F32), TensorInfo(TensorShape(15U, 5, 5, 10U), 1, DataType::F32), TensorInfo(TensorShape(15U, 5, 5, 20U), 1, DataType::S32), TensorInfo(TensorShape(5U, 5, 5, 20U), 1, DataType::F32), TensorInfo(TensorShape(15U, 5, 5, 20U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, false, false, false, false, false, false})), input, boxes, box_ind, output, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLCropResizeFixture< float >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallCropResizeDataset(), combine(framework::dataset::make("IsOutOfBounds", { true, false }), framework::dataset::make("DataType", DataType::F32))))
 
 combine (datasets::SmallCropResizeDataset(), combine(framework::dataset::make("IsOutOfBounds", { true, false }), framework::dataset::make("DataType", DataType::U16))))
 
 combine (datasets::SmallCropResizeDataset(), combine(framework::dataset::make("IsOutOfBounds", { true, false }), framework::dataset::make("DataType", DataType::S16))))
 
 combine (datasets::SmallCropResizeDataset(), combine(framework::dataset::make("IsOutOfBounds", { true, false }), framework::dataset::make("DataType", DataType::U32))))
 
 combine (datasets::SmallCropResizeDataset(), combine(framework::dataset::make("IsOutOfBounds", { true, false }), framework::dataset::make("DataType", DataType::S32))))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(13U, 11U, 4U, 3U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 2U), 1, DataType::F32), }), framework::dataset::make("WeightsInfo", { TensorInfo(TensorShape(3U, 3U, 2U, 2U), 1, DataType::F16), TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U, 2U), 1, DataType::F16), TensorInfo(TensorShape(3U, 2U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 4U), 1, DataType::F32), TensorInfo(TensorShape(1U, 1U, 2U, 4U), 1, DataType::F32), })), framework::dataset::make("BiasInfo", { TensorInfo(TensorShape(1U), 1, DataType::F16), TensorInfo(TensorShape(1U), 1, DataType::F32), TensorInfo(TensorShape(1U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U), 1, DataType::F32), TensorInfo(TensorShape(1U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(25U, 11U, 2U), 1, DataType::F16), TensorInfo(TensorShape(25U, 10U, 2U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(13U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(11U, 9U, 1U, 3U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 4U), 1, DataType::F32), })), framework::dataset::make("PadStrideInfo", { PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 1, 1), PadStrideInfo(1, 1, 0, 0), })), framework::dataset::make("Expected", { false, false, false, false, false, true })), input_info, weights_info, bias_info, output_info, pad_info, expected)
 
 FIXTURE_DATA_TEST_CASE (Run, CLDeconvolutionLayerFixture4x4< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(data4x4, framework::dataset::make("DataType", DataType::F32)), data_layouts_dataset), add_bias_dataset))
 
 combine (combine(combine(data3x3_precommit, framework::dataset::make("DataType", DataType::F32)), data_layouts_dataset), add_bias_dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDeconvolutionLayerFixture3x3< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(data3x3, framework::dataset::make("DataType", DataType::F32)), data_layouts_dataset), add_bias_dataset))
 
 combine (combine(combine(data2x2_precommit, framework::dataset::make("DataType", DataType::F32)), data_layouts_dataset), add_bias_dataset))
 
 combine (combine(combine(data1x1, framework::dataset::make("DataType", DataType::F32)), data_layouts_dataset), add_bias_dataset))
 
 combine (combine(combine(data4x4, framework::dataset::make("DataType", DataType::F16)), data_layouts_dataset), add_bias_dataset))
 
 combine (combine(combine(data3x3_precommit, framework::dataset::make("DataType", DataType::F16)), data_layouts_dataset), add_bias_dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDeconvolutionLayerFixture3x3< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(data3x3, framework::dataset::make("DataType", DataType::F16)), data_layouts_dataset), add_bias_dataset))
 
 combine (combine(combine(data2x2_precommit, framework::dataset::make("DataType", DataType::F16)), data_layouts_dataset), add_bias_dataset))
 
 combine (combine(combine(data1x1, framework::dataset::make("DataType", DataType::F16)), data_layouts_dataset), add_bias_dataset))
 
 FIXTURE_DATA_TEST_CASE (Run, CLDeconvolutionLayerQuantizedFixture4x4< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(data4x4, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("QuantizationInfo", QuantizationInfo(2.f/255.f, 0))), add_bias_dataset))
 
 combine (combine(combine(combine(data3x3_precommit, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("QuantizationInfo", QuantizationInfo(2.f/255.f, 0))), add_bias_dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDeconvolutionLayerQuantizedFixture3x3< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(data3x3, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("QuantizationInfo", QuantizationInfo(2.f/255.f, 0))), add_bias_dataset))
 
 combine (combine(combine(combine(data2x2_precommit, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("QuantizationInfo", QuantizationInfo(2.f/255.f, 0))), add_bias_dataset))
 
 combine (combine(combine(combine(data1x1, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("QuantizationInfo", QuantizationInfo(2.f/255.f, 0))), add_bias_dataset))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("InputInfo1", { TensorInfo(TensorShape(23U, 27U, 5U), 1, DataType::F32), TensorInfo(TensorShape(24U, 27U, 4U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 3U), 1, DataType::F32), TensorInfo(TensorShape(16U, 27U, 6U), 1, DataType::F32) }), framework::dataset::make("InputInfo2", { TensorInfo(TensorShape(23U, 27U, 4U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 5U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 4U), 1, DataType::F32), TensorInfo(TensorShape(16U, 27U, 6U), 1, DataType::F32) })), framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(23U, 27U, 9U), 1, DataType::F16), TensorInfo(TensorShape(25U, 12U, 9U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 8U), 1, DataType::F32), TensorInfo(TensorShape(16U, 27U, 12U), 1, DataType::F32) })), framework::dataset::make("Expected", { false, false, false, true })), input_info1, input_info2, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConcatenateLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(concat(datasets::Small3DShapes(), datasets::Tiny4DShapes()), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("Axis", 2)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConcatenateLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(concat(datasets::Large3DShapes(), datasets::Small4DShapes()), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("Axis", 2)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConcatenateLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(concat(datasets::Small3DShapes(), datasets::Tiny4DShapes()), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("Axis", 2)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConcatenateLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::ConcatenateLayerShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("Axis", 2)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConcatenateLayerFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(concat(datasets::Small3DShapes(), datasets::Tiny4DShapes()), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("Axis", 2)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConcatenateLayerFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::ConcatenateLayerShapes(), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("Axis", 2)))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 32U, 2U), 1, DataType::U8), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(32U, 32U, 2U), 1, DataType::U16), })), framework::dataset::make("Policy",{ ConvertPolicy::WRAP, ConvertPolicy::WRAP, ConvertPolicy::WRAP, ConvertPolicy::WRAP, ConvertPolicy::WRAP, ConvertPolicy::WRAP, })), framework::dataset::make("Shift",{ 1, 1, 8, 1, 1, 1, })), framework::dataset::make("Expected", { false, false, false, false, false, true})), input_info, output_info, policy, shift, expected)
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetNightly), shape, policy, shift)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConvertLayerToU16Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toU16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetPrecommit))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConvertLayerToU16Fixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toU16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetNightly))
 
 combine (combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetNightly)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConvertLayerToS16Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toS16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetPrecommit))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConvertLayerToS16Fixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toS16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetNightly))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConvertLayerToS32Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toS32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetPrecommit))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConvertLayerToS32Fixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toS32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetNightly))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConvertLayerToU8Fixture< uint16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU16toU8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetPrecommit))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConvertLayerToU8Fixture< uint16_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU16toU8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetNightly))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConvertLayerToU32Fixture< uint16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU16toU32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetPrecommit))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConvertLayerToU32Fixture< uint16_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU16toU32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetNightly))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConvertLayerToU8Fixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS16toU8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetPrecommit))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConvertLayerToU8Fixture< int16_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS16toU8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetNightly))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthConvertLayerToS32Fixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS16toS32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetPrecommit))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthConvertLayerToS32Fixture< int16_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS16toS32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerShiftDatasetNightly))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(16U, 8U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(16U, 8U, 4U, 4U), 1, DataType::F32), TensorInfo(TensorShape(16U, 8U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(16U, 8U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 2U, 4U, 4U), 1, DataType::F32), }), framework::dataset::make("BlockShape", { 2, 1, 2, 2, 2 })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 16U, 1U, 4U), 1, DataType::F32), TensorInfo(TensorShape(64U, 16U, 1U, 4U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 2U, 1U), 1, DataType::F16), TensorInfo(TensorShape(32U, 16U, 2U, 1U), 1, DataType::F32), TensorInfo(TensorShape(32U, 8U, 2U, 1U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, false, false, false, false})), input_info, block_shape, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthToSpaceLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallDepthToSpaceLayerDataset(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthToSpaceLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeDepthToSpaceLayerDataset(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 combine (combine(datasets::SmallDepthToSpaceLayerDataset(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthToSpaceLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeDepthToSpaceLayerDataset(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 DATA_TEST_CASE (Validate3x3, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 18U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 3U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(32U, 18U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 8U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 8U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 8U), 1, DataType::F32), TensorInfo(TensorShape(50U, 32U, 8U), 1, DataType::QASYMM8), }), framework::dataset::make("WeightsInfo", { TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F16), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(5U, 5U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 16U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 16U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 16U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 24U), 1, DataType::QASYMM8), })), framework::dataset::make("BiasesInfo", { TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::S32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(16U), 1, DataType::F32), TensorInfo(TensorShape(16U), 1, DataType::F32), TensorInfo(TensorShape(16U), 1, DataType::F32), TensorInfo(TensorShape(24U), 1, DataType::S32), })), framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(30U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(30U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(30U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(30U, 16U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(30U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(30U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(30U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(30U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 18U, 2U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(30U, 16U, 16U), 1, DataType::F32), TensorInfo(TensorShape(30U, 16U, 16U), 1, DataType::F32), TensorInfo(TensorShape(30U, 16U, 16U), 1, DataType::F32), TensorInfo(TensorShape(48U, 30U, 24U), 1, DataType::QASYMM8), })), framework::dataset::make("ConvInfo", { PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(4, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), })), framework::dataset::make("DepthMultiplier", { 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 2, 2, 2, 3, })), framework::dataset::make("ActivationInfo", { ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LINEAR), ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), })), framework::dataset::make("Dilation", { Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(20U, 1U), Size2D(0U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), })), framework::dataset::make("Expected", { false, false, false, false, false, false, false, false, false, false, false, false, true, true })), input_info, weights_info, biases_info, output_info, conv_info, depth_multiplier, act_info, dilation, expected)
 
 DATA_TEST_CASE (ValidateGeneric, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 3U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 8U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 8U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 8U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 8U), 1, DataType::QASYMM8), }), framework::dataset::make("WeightsInfo", { TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F16), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 16U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 16U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 16U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 24U), 1, DataType::QASYMM8), })), framework::dataset::make("BiasesInfo", { TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(16U), 1, DataType::F32), TensorInfo(TensorShape(16U), 1, DataType::F32), TensorInfo(TensorShape(16U), 1, DataType::F32), TensorInfo(TensorShape(24U), 1, DataType::S32), })), framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(25U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 16U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 16U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 16U), 1, DataType::F32), TensorInfo(TensorShape(32U, 11U, 24U), 1, DataType::QASYMM8), })), framework::dataset::make("ConvInfo", { PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 1, 0), })), framework::dataset::make("DepthMultiplier", { 1, 1, 3, 1, 1, 1, 2, 2, 2, 3, })), framework::dataset::make("Dilation", { Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(20U, 1U), Size2D(0U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), })), framework::dataset::make("Expected", { false, false, false, false, false, false, false, false, true, true })), input_info, weights_info, biases_info, output_info, conv_info, depth_multiplier, dilation, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(framework::dataset::concat(datasets::SmallDepthwiseConvolutionLayerDataset3x3(), datasets::SmallDepthwiseConvolutionLayerDataset3x3NCHW()), depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", DataLayout::NCHW)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", DataLayout::NCHW)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW })), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", DataLayout::NHWC)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", DataLayout::NHWC)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NHWC })), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(framework::dataset::concat(datasets::SmallDepthwiseConvolutionLayerDataset3x3(), datasets::SmallDepthwiseConvolutionLayerDataset3x3NCHW()), depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", DataLayout::NCHW)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", DataLayout::NCHW)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", DataLayout::NCHW)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", DataLayout::NCHW)), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", DataLayout::NHWC)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", DataLayout::NHWC)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", DataLayout::NHWC)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", DataLayout::NHWC)), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.3f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 4) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset(), large_depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.7f, 2) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.8, 1) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset(), large_depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.9f, 11) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.3f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDepthwiseConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDepthwiseConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::QASYMM8), TensorInfo(TensorShape(16U, 16U, 2U, 5U), 1, DataType::QASYMM8), TensorInfo(TensorShape(17U, 16U, 16U, 5U), 1, DataType::QASYMM8), TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::QASYMM8), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::U8), TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), TensorInfo(TensorShape(17U, 16U, 16U, 5U), 1, DataType::F32), TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), })), framework::dataset::make("Expected", { false, false, false, true, true})), input_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDequantizationLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), datasets::QuantizedTypes()), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDequantizationLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), datasets::QuantizedTypes()), framework::dataset::make("DataType", DataType::F16)))
 
 combine (combine(datasets::SmallShapes(), datasets::QuantizedTypes()), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDequantizationLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), datasets::QuantizedTypes()), framework::dataset::make("DataType", DataType::F32)))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(combine(datasets::Small2DShapes(), datasets::BorderModes()), framework::dataset::make("Format", Format::U8)), shape, border_mode, format)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDerivativeFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::Small2DShapes(), datasets::BorderModes()), framework::dataset::make("Format", Format::U8)), datasets::GradientDimensions()))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDerivativeFixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::Large2DShapes(), datasets::BorderModes()), framework::dataset::make("Format", Format::U8)), datasets::GradientDimensions()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDilateFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDilateFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 DATA_TEST_CASE (ValidateConvolutionMethod, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(17U, 31U, 2U), 1, DataType::F32), TensorInfo(TensorShape(17U, 31U, 2U), 1, DataType::F32), TensorInfo(TensorShape(23U, 27U, 23U, 4U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U, 1U), 1, DataType::F32), TensorInfo(TensorShape(33U, 27U, 7U, 4U), 1, DataType::F32) }), framework::dataset::make("WeightsInfo", { TensorInfo(TensorShape(5U, 5U, 2U, 19U), 1, DataType::F32), TensorInfo(TensorShape(5U, 5U, 2U, 19U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 23U, 21U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 5U, 21U), 1, DataType::F32), TensorInfo(TensorShape(5U, 5U, 7U, 16U), 1, DataType::F16) })), framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(15U, 15U, 19U), 1, DataType::F32), TensorInfo(TensorShape(15U, 15U, 19U), 1, DataType::F32), TensorInfo(TensorShape(21U, 25U, 21U, 4U), 1, DataType::F32), TensorInfo(TensorShape(11U, 25U, 21U), 1, DataType::F32), TensorInfo(TensorShape(11U, 12U, 16U, 4U), 1, DataType::F32) })), framework::dataset::make("ConvInfo", { PadStrideInfo(1, 2, 1, 1), PadStrideInfo(1, 2, 1, 1), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(2, 1, 0, 0), PadStrideInfo(3, 2, 1, 0) })), framework::dataset::make("GpuTarget", { GPUTarget::BIFROST, GPUTarget::MIDGARD, GPUTarget::G71, GPUTarget::MIDGARD, GPUTarget::BIFROST })), framework::dataset::make("Dilation", { Size2D(1U, 1U), Size2D(1U, 1U), Size2D(1U, 1U), Size2D(2U, 2U), Size2D(3U, 3U) })), framework::dataset::make("Expected", { ConvolutionMethod::GEMM, ConvolutionMethod::GEMM, ConvolutionMethod::WINOGRAD, ConvolutionMethod::GEMM, ConvolutionMethod::GEMM })), input_info, weights_info, output_info, conv_info, gpu_target, dilation, expected)
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallDilatedConvolutionLayerDataset(), CNNDataTypes), input_shape, weights_shape, bias_shape, output_shape, info, dilation, data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMDilatedConvolutionLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallDilatedConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), framework::dataset::make("ActivationLayerInfo", ActivationLayerInfo())))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMDilatedConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDilatedConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), framework::dataset::make("ActivationLayerInfo", ActivationLayerInfo())))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMDilatedConvolutionLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallDilatedConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), framework::dataset::make("ActivationLayerInfo", ActivationLayerInfo())))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMDilatedConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeDilatedConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), framework::dataset::make("ActivationLayerInfo", ActivationLayerInfo())))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMDilatedConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallDilatedConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("DataLayout", { DataLayout::NCHW })), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255.f, 10) })), framework::dataset::make("ActivationLayerInfo", { ActivationLayerInfo() })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMDilatedConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(datasets::LargeDilatedConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("DataLayout", { DataLayout::NCHW })), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255.f, 0) })), framework::dataset::make("ActivationLayerInfo", { ActivationLayerInfo() })))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 2U), 1, DataType::F32), }), framework::dataset::make("WeightsInfo",{ TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F16), TensorInfo(TensorShape(3U, 3U, 3U, 4U), 1, DataType::F32), TensorInfo(TensorShape(11U, 11U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(5U, 3U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U, 4U, 3U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32), TensorInfo(TensorShape(1U, 1U, 2U, 4U), 1, DataType::F32), })), framework::dataset::make("BiasesInfo",{ TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(3U), 1, DataType::F32), TensorInfo(TensorShape(4U, 2U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), TensorInfo(TensorShape(4U), 1, DataType::F32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(25U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(26U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(25U, 11U, 4U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 4U), 1, DataType::F32), })), framework::dataset::make("ConvInfo", { PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(3, 3, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), PadStrideInfo(1, 1, 0, 0), })), framework::dataset::make("ActivationInfo", { ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU) })), framework::dataset::make("Expected", { false, false, false, false, false, false, false, false, false, false, true })), input_info, weights_info, biases_info, output_info, conv_info, act_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDirectConvolutionLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(data_precommit, framework::dataset::make("DataType", DataType::F16)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", DataLayout::NCHW)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDirectConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(data_nightly, framework::dataset::make("DataType", DataType::F16)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", DataLayout::NCHW)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge9x9, CLDirectConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(data_nightly_9x9, framework::dataset::make("DataType", DataType::F16)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall9x9, CLDirectConvolutionLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(data_precommit_9x9, framework::dataset::make("DataType", DataType::F16)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NHWC })))
 
 combine (combine(combine(data_precommit, framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDirectConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(data_nightly, framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge9x9, CLDirectConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(data_nightly_9x9, framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall9x9, CLDirectConvolutionLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(data_precommit_9x9, framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NHWC })))
 
 combine (combine(datasets::DirectConvolutionLayerDataset(), framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDirectConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(data_precommit, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 10) })), QuantizedActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDirectConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(data_nightly, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 10) })), QuantizedActivationFunctionsDataset))
 
 combine (combine(combine(datasets::DirectConvolutionLayerDataset(), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 127) })), QuantizedActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), ElementwiseMaxU8Dataset))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), shape, data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxFixture< int16_t >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMaxS16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseMaxQASYMM8Dataset), framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f/255.f, 20) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/255.f, 10) })), framework::dataset::make("OutQInfo", { QuantizationInfo(1.f/255.f, 5) })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxQuantizedFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseMaxQSYMM16Dataset), framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("OutQInfo", { QuantizationInfo(5.f/32768.f, 0) })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxFixture< half >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMaxFP16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxFixture< float >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMaxFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwiseMaxBroadcastFixture< float >, framework::DatasetMode::ALL, combine(datasets::SmallShapesBroadcast(), ElementwiseMaxFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), ElementwiseMinU8Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinFixture< int16_t >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMinS16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseMinQASYMM8Dataset), framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f/255.f, 20) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/255.f, 10) })), framework::dataset::make("OutQInfo", { QuantizationInfo(1.f/255.f, 5) })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinQuantizedFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseMinQSYMM16Dataset), framework::dataset::make("SrcQInfo0", { QuantizationInfo(1.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("SrcQInfo1", { QuantizationInfo(2.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("OutQInfo", { QuantizationInfo(5.f/32768.f, 0) })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinFixture< half >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMinFP16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinFixture< float >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMinFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwiseMinBroadcastFixture< float >, framework::DatasetMode::ALL, combine(datasets::SmallShapesBroadcast(), ElementwiseMinFP32Dataset))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("Input1Info", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), }), framework::dataset::make("Input2Info",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, true, false, false, false})), input1_info, input2_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwisePowerFixture< half >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwisePowerFP16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwisePowerBroadcastFixture< half >, framework::DatasetMode::ALL, combine(datasets::SmallShapesBroadcast(), ElementwisePowerFP16Dataset))
 
 combine (datasets::SmallShapes(), ElementwisePowerFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwisePowerBroadcastFixture< float >, framework::DatasetMode::ALL, combine(datasets::SmallShapesBroadcast(), ElementwisePowerFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), ElementwiseSquaredDiffU8Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffFixture< int16_t >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseSquaredDiffS16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseSquaredDiffQASYMM8Dataset), framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f/255.f, 20) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/255.f, 10) })), framework::dataset::make("OutQInfo", { QuantizationInfo(1.f/255.f, 5) })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffQuantizedFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseSquaredDiffQSYMM16Dataset), framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/32768.f, 0), QuantizationInfo(5.f/32768.f, 0) })), framework::dataset::make("OutQInfo", { QuantizationInfo(5.f/32768.f, 0) })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffFixture< half >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseSquaredDiffFP16Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffFixture< float >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseSquaredDiffFP32Dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwiseSquaredDiffBroadcastFixture< float >, framework::DatasetMode::ALL, combine(datasets::SmallShapesBroadcast(), ElementwiseSquaredDiffFP32Dataset))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::Small2DShapes(), framework::dataset::make("DataType", DataType::U8)), shape, data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLEqualizeHistogramFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(datasets::Small2DShapes(), framework::dataset::make("DataType", DataType::U8)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLEqualizeHistogramFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::Large2DShapes(), framework::dataset::make("DataType", DataType::U8)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLErodeFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLErodeFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLExpLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLExpLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLExpLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::F32)))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(combine(combine(concat(datasets::Small2DShapes(), datasets::Large2DShapes()), framework::dataset::make("Format", Format::U8)), framework::dataset::make("SuppressNonMax", { false, true })), framework::dataset::make("BorderMode", BorderMode::UNDEFINED)), shape, format, suppress_nonmax, border_mode)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFastCornersFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallImageFiles(), framework::dataset::make("Format", Format::U8)), framework::dataset::make("SuppressNonMax", { false, true })), framework::dataset::make("BorderMode", BorderMode::UNDEFINED)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFastCornersFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeImageFiles(), framework::dataset::make("Format", Format::U8)), framework::dataset::make("SuppressNonMax", { false, true })), framework::dataset::make("BorderMode", BorderMode::UNDEFINED)))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(shapes_1d, data_types), shape, data_type)
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 3, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(11U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(25U, 13U, 2U), 2, DataType::F32), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 2, DataType::F16), TensorInfo(TensorShape(16U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(11U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(25U, 13U, 2U), 2, DataType::F32), })), framework::dataset::make("Axis", { 0, 0, 0, 2, 0, 0 })), framework::dataset::make("Expected", { false, false, false, false, false, true })), input_info, output_info, axis, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFFT1DFixture< float >, framework::DatasetMode::ALL, combine(shapes_1d, framework::dataset::make("DataType", DataType::F32)))
 
 combine (shapes_2d, data_types)
 
 validate (src.info() ->valid_region(), valid_region)
 
 validate (src.info() ->padding(), PaddingSize())
 
 validate (dst.info() ->padding(), PaddingSize())
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 25U, 2U), 2, DataType::F32), TensorInfo(TensorShape(32U, 25U, 2U), 2, DataType::F32), TensorInfo(TensorShape(32U, 25U, 2U), 3, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(32U, 25U, 2U), 2, DataType::F32), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 25U, 2U), 2, DataType::F16), TensorInfo(TensorShape(16U, 25U, 2U), 2, DataType::F32), TensorInfo(TensorShape(32U, 25U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 2, DataType::F32), TensorInfo(TensorShape(32U, 25U, 2U), 2, DataType::F32), })), framework::dataset::make("Expected", { false, false, false, false, true })), input_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFFT2DFixture< float >, framework::DatasetMode::ALL, combine(shapes_2d, framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFFTConvolutionLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallFFTConvolutionLayerDataset(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsSmallDataset))
 
 DATA_TEST_CASE (FillBorder, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallShapes(), datasets::BorderModes()), BorderSizesDataset), PaddingSizesDataset), framework::dataset::make("DataType", DataType::U8)), shape, border_mode, size, padding, data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFlattenLayerFixture< float >, framework::DatasetMode::ALL, combine(framework::dataset::concat(datasets::Small3DShapes(), datasets::Small4DShapes()), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFlattenLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(framework::dataset::concat(datasets::Large3DShapes(), datasets::Large4DShapes()), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFlattenLayerFixture< half >, framework::DatasetMode::ALL, combine(framework::dataset::concat(datasets::Small3DShapes(), datasets::Small4DShapes()), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFlattenLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(framework::dataset::concat(datasets::Large3DShapes(), datasets::Large4DShapes()), framework::dataset::make("DataType", DataType::F16)))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), })), framework::dataset::make("Expected", { false, false, false, false, true })), input_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFloorFixture< half >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFloorFixture< half >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFloorFixture< float >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::F32)))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallFullyConnectedLayerDataset(), FullyConnectedParameters), CNNDataTypes), src_shape, weights_shape, bias_shape, dst_shape, transpose_weights, reshape_weights, data_type)
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(9U, 5U, 7U, 3U), 1, DataType::F32), TensorInfo(TensorShape(8U, 4U, 6U, 4U), 1, DataType::F32), TensorInfo(TensorShape(8U, 4U, 6U, 4U), 1, DataType::F32), TensorInfo(TensorShape(9U, 5U, 7U, 3U), 1, DataType::F32), TensorInfo(TensorShape(9U, 5U, 7U, 3U), 1, DataType::F32), }), framework::dataset::make("WeightsInfo",{ TensorInfo(TensorShape(315U, 271U), 1, DataType::F16), TensorInfo(TensorShape(192U, 192U), 1, DataType::F32), TensorInfo(TensorShape(192U, 192U), 1, DataType::F32), TensorInfo(TensorShape(217U, 231U), 1, DataType::F32), TensorInfo(TensorShape(217U, 315U), 1, DataType::F32), })), framework::dataset::make("BiasInfo",{ TensorInfo(TensorShape(271U), 1, DataType::F32), TensorInfo(TensorShape(192U), 1, DataType::F32), TensorInfo(TensorShape(192U), 1, DataType::F32), TensorInfo(TensorShape(271U), 1, DataType::F32), TensorInfo(TensorShape(271U), 1, DataType::F32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(271U, 3U), 1, DataType::F32), TensorInfo(TensorShape(192U, 4U), 1, DataType::F32), TensorInfo(TensorShape(192U, 4U), 1, DataType::F32), TensorInfo(TensorShape(271U, 3U), 1, DataType::F32), TensorInfo(TensorShape(271U, 3U), 1, DataType::F32), })), framework::dataset::make("TransposeWeights",{ true, true, false, true, true })), framework::dataset::make("ReshapedWeights",{ false, false, false, false, false})), framework::dataset::make("Expected", { false, true, true, false, false })), input_info, weights_info, bias_info, output_info, transpose_weights, reshaped_weights, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFullyConnectedLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFullyConnectedLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFullyConnectedLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFullyConnectedLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFullyConnectedLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.f/255.f, 10) })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFullyConnectedLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.f/256.f, 10) })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFuseBatchNormalizationConvFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(shape_conv_values_precommit, framework::dataset::make("DataType", { DataType::F32 })), data_layout_values), in_place_values), with_bias_values), with_gamma_values), with_beta_values))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFuseBatchNormalizationConvFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(shape_conv_values_nightly, framework::dataset::make("DataType", { DataType::F32 })), data_layout_values), in_place_values), with_bias_values), with_gamma_values), with_beta_values))
 
 combine (combine(combine(combine(combine(combine(shape_conv_values_precommit, framework::dataset::make("DataType", { DataType::F16 })), data_layout_values), in_place_values), with_bias_values), with_gamma_values), with_beta_values))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFuseBatchNormalizationConvFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(shape_conv_values_nightly, framework::dataset::make("DataType", { DataType::F16 })), data_layout_values), in_place_values), with_bias_values), with_gamma_values), with_beta_values))
 
 combine (combine(combine(combine(combine(combine(datasets::Small3DShapes(), framework::dataset::make("DataType", { DataType::F32 })), data_layout_values), in_place_values), with_bias_values), with_gamma_values), with_beta_values))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFuseBatchNormalizationDWCFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::Large3DShapes(), framework::dataset::make("DataType", { DataType::F32 })), data_layout_values), in_place_values), with_bias_values), with_gamma_values), with_beta_values))
 
 combine (combine(combine(combine(combine(combine(datasets::Small3DShapes(), framework::dataset::make("DataType", { DataType::F16 })), data_layout_values), in_place_values), with_bias_values), with_gamma_values), with_beta_values))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFuseBatchNormalizationDWCFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::Large3DShapes(), framework::dataset::make("DataType", { DataType::F16 })), data_layout_values), in_place_values), with_bias_values), with_gamma_values), with_beta_values))
 
 DATA_TEST_CASE (Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(27U, 27U), 1, DataType::F16), TensorInfo(TensorShape(27U, 27U), 1, DataType::F32), TensorInfo(TensorShape(27U, 27U), 1, DataType::F32), TensorInfo(TensorShape(27U, 27U), 1, DataType::F32), TensorInfo(TensorShape(27U, 27U), 1, DataType::F32), TensorInfo(TensorShape(5U, 5U, 5U, 5U, 5U), 1, DataType::F32), TensorInfo(TensorShape(27U, 27U), 1, DataType::F16), TensorInfo(TensorShape(27U, 27U), 1, DataType::F32), TensorInfo(TensorShape(27U, 27U), 1, DataType::F16), }), framework::dataset::make("IndicesInfo", { TensorInfo(TensorShape(10U), 1, DataType::U32), TensorInfo(TensorShape(10U), 1, DataType::U32), TensorInfo(TensorShape(10U), 1, DataType::U32), TensorInfo(TensorShape(10U), 1, DataType::U8), TensorInfo(TensorShape(10U, 10U), 1, DataType::U32), TensorInfo(TensorShape(10U), 1, DataType::U32), TensorInfo(TensorShape(10U), 1, DataType::U32), TensorInfo(TensorShape(10U), 1, DataType::U32), TensorInfo(TensorShape(10U), 1, DataType::U32), })), framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(10U, 27U), 1, DataType::F16), TensorInfo(TensorShape(27U, 10U), 1, DataType::F32), TensorInfo(TensorShape(10U, 27U), 1, DataType::F32), TensorInfo(TensorShape(10U, 27U), 1, DataType::F32), TensorInfo(TensorShape(27U, 10U), 1, DataType::F32), TensorInfo(TensorShape(10U, 5U, 5U, 5U, 5U), 1, DataType::F32), TensorInfo(TensorShape(27U, 10U), 1, DataType::F32), TensorInfo(TensorShape(27U, 27U), 1, DataType::F32), TensorInfo(TensorShape(27U, 27U), 1, DataType::F16), })), framework::dataset::make("Axis", { 0, 1, -2, 0, 1, 0, 1, 2, -3, })), framework::dataset::make("Expected", { true, true, true, false, false, false, false, false, false })), input_info, indices_info, output_info, axis, expected)
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(arm_compute::test::datasets::SmallGatherDataset(), framework::dataset::make("DataType", { DataType::F16, DataType::F32 })), input_shape, indices_shape, axis, data_type)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGatherFixture< half >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallGatherDataset(), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGatherFixture< half >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGatherDataset(), framework::dataset::make("DataType", DataType::F16)))
 
 combine (datasets::SmallGatherDataset(), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGatherFixture< float >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGatherDataset(), framework::dataset::make("DataType", DataType::F32)))
 
 combine (datasets::SmallGatherDataset(), framework::dataset::make("DataType", DataType::U8)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGatherFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGatherDataset(), framework::dataset::make("DataType", DataType::U8)))
 
 combine (datasets::SmallGatherDataset(), framework::dataset::make("DataType", DataType::U16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGatherFixture< uint16_t >, framework::DatasetMode::NIGHTLY, combine(datasets::LargeGatherDataset(), framework::dataset::make("DataType", DataType::U16)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGaussian3x3Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGaussian3x3Fixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGaussian5x5Fixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGaussian5x5Fixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::U8)), datasets::BorderModes()))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, large_gaussian_pyramid_levels, shape, border_mode, num_levels)
 
 FIXTURE_DATA_TEST_CASE (RunSmallGaussianPyramidHalf, CLGaussianPyramidHalfFixture< uint8_t >, framework::DatasetMode::ALL, small_gaussian_pyramid_levels)
 
 FIXTURE_DATA_TEST_CASE (RunLargeGaussianPyramidHalf, CLGaussianPyramidHalfFixture< uint8_t >, framework::DatasetMode::NIGHTLY, large_gaussian_pyramid_levels)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMFixture< half >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallGEMMDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeGEMMDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallGEMMDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeGEMMDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMInputOutput3DFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallGEMMInputOutput3DDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMInputOutput3DFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeGEMMInputOutput3DDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F32)))
 
 combine (combine(datasets::SmallGEMMInputOutput3DDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMInputOutput3DFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeGEMMInputOutput3DDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F16)))
 
 combine (combine(datasets::SmallGEMMOutput3DDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMOutput3DFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeGEMMOutput3DDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F32)))
 
 combine (combine(datasets::SmallGEMMOutput3DDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F16)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMOutput3DFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeGEMMOutput3DDataset(), framework::dataset::make("ReshapeWeights", { true, false })), framework::dataset::make("DataType", DataType::F16)))
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, datasets::SmallGEMMLowpDataset(), shape_a, shape_b, shape_c, a_offset, b_offset)
 
 DATA_TEST_CASE (Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), quantize_down_int32_to_uint8_scale_cases), shape, result_offset, result_mult_int, result_shift, min, max, add_bias)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMLowpQuantizeDownInt32ToUint8ScaleFixture, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), quantize_down_int32_to_uint8_scale_cases))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLGEMMLowpQuantizeDownInt32ToUint8ScaleFixture, fram