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

Namespaces

 detail
 
 reference
 

Data Structures

class  AbsoluteTolerance
 Class reprensenting an absolute tolerance value. 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  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 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 CLArithmeticAdditionBroadcastQuantizedFixture = ArithmeticAdditionValidationQuantizedBroadcastFixture< CLTensor, CLAccessor, CLArithmeticAddition, T >
 
template<typename T >
using CLArithmeticAdditionBroadcastFloatFixture = ArithmeticAdditionBroadcastValidationFloatFixture< CLTensor, CLAccessor, CLArithmeticAddition, T >
 
using CLArithmeticDivisionIntegerFixture = ArithmeticDivisionValidationIntegerFixture< CLTensor, CLAccessor, CLArithmeticDivision, int >
 
template<typename T >
using CLArithmeticDivisionFloatFixture = ArithmeticDivisionValidationFloatFixture< CLTensor, CLAccessor, CLArithmeticDivision, T >
 
template<typename T >
using CLArithmeticDivisionBroadcastFloatFixture = ArithmeticDivisionBroadcastValidationFloatFixture< CLTensor, CLAccessor, CLArithmeticDivision, T >
 
template<typename T >
using CLArithmeticSubtractionBroadcastFloatFixture = ArithmeticSubtractionBroadcastValidationFloatFixture< 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 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 CLChannelShuffleLayerFixture = ChannelShuffleLayerValidationFixture< CLTensor, CLAccessor, CLChannelShuffleLayer, T >
 
using ClCol2Im = ClSynthetizeOperatorWithBorder< opencl::kernels::ClCol2ImKernel >
 
template<typename T >
using ClCol2ImFixture = Col2ImOpValidationFixture< CLTensor, CLAccessor, ClCol2Im, T, true >
 
template<typename T >
using CLComparisonFixture = ComparisonValidationFixture< CLTensor, CLAccessor, CLComparison, T >
 
template<typename T >
using CLConvertFullyConnectedWeightsFixture = ConvertFullyConnectedWeightsValidationFixture< CLTensor, CLAccessor, CLConvertFullyConnectedWeights, T >
 
template<typename T >
using CLGEMMConvolutionLayerMixedDataLayoutFixture = ConvolutionValidationFixture< CLTensor, CLAccessor, CLGEMMConvolutionLayer, T, true >
 
template<typename T >
using CLGEMMConvolutionLayerQuantizedMixedDataLayoutFixture = ConvolutionValidationQuantizedFixture< CLTensor, CLAccessor, CLGEMMConvolutionLayer, T, true >
 
template<typename T >
using CLGEMMConvolutionLayerQuantizedPerChannelFixture = ConvolutionValidationQuantizedPerChannelFixture< CLTensor, CLAccessor, CLGEMMConvolutionLayer, T, int8_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 CLDeconvolutionLayerAsymmFixture3x3 = DeconvolutionValidationAsymmFixture< 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 CLDeconvolutionLayerAsymmFixture9x9 = DeconvolutionValidationAsymmFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, 9, 9 >
 
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 CLDeconvolutionLayerQuantizedPerChannelFixture4x4 = DeconvolutionValidationQuantizedPerChannelFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, int8_t, 4, 4 >
 
template<typename T >
using CLDeconvolutionLayerQuantizedPerChannelFixture3x3 = DeconvolutionValidationQuantizedPerChannelFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, int8_t, 3, 3 >
 
template<typename T >
using CLDeconvolutionLayerQuantizedPerChannelFixture2x2 = DeconvolutionValidationQuantizedPerChannelFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, int8_t, 2, 2 >
 
template<typename T >
using CLDeconvolutionLayerQuantizedPerChannelFixture1x1 = DeconvolutionValidationQuantizedPerChannelFixture< CLTensor, CLAccessor, CLDeconvolutionLayer, T, int8_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 CLDepthwiseConvolutionLayerMixedDataLayoutFixture = DepthwiseConvolutionLayerValidationFixture< CLTensor, CLAccessor, CLDepthwiseConvolutionLayer, T, true >
 
template<typename T >
using CLDepthwiseConvolutionLayerInPlaceFixture = DepthwiseConvolutionLayerValidationFixture< CLTensor, CLAccessor, CLDepthwiseConvolutionLayer, T, false, true >
 
template<typename T >
using CLDepthwiseConvolutionLayerQuantizedMixedDataLayoutFixture = DepthwiseConvolutionLayerValidationQuantizedFixture< CLTensor, CLAccessor, CLDepthwiseConvolutionLayer, T, true >
 
template<typename T >
using CLDepthwiseConvolutionLayerQuantizedPerChannelFixture = DepthwiseConvolutionLayerValidationQuantizedPerChannelFixture< CLTensor, CLAccessor, CLDepthwiseConvolutionLayer, T, int8_t >
 
using CLDepthwiseConvolutionLayerNative = CLSynthetizeFunction< CLDepthwiseConvolutionLayerNativeKernel >
 
template<typename T >
using CLDepthwiseConvolutionLayerNativeFixture = DepthwiseConvolutionLayerNativeConfigurableValidationFixture< CLTensor, CLAccessor, CLDepthwiseConvolutionLayerNative, T >
 
template<typename T >
using CLDequantizationLayerFixture = DequantizationValidationFixture< CLTensor, CLAccessor, CLDequantizationLayer, 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 CLDirectConvolutionLayerMixedDataLayoutFixture = DirectConvolutionValidationFixture< CLTensor, CLAccessor, CLDirectConvolutionLayer, T, true >
 
template<typename T >
using CLDirectConvolutionValidationWithTensorShapesFixture = DirectConvolutionValidationWithTensorShapesFixture< CLTensor, CLAccessor, CLDirectConvolutionLayer, T >
 
template<typename T >
using CLDirectConvolutionLayerQuantizedFixture = DirectConvolutionValidationQuantizedFixture< CLTensor, CLAccessor, CLDirectConvolutionLayer, T >
 
template<typename T >
using CLDirectConvolutionLayerQuantizedMixedDataLayoutFixture = DirectConvolutionValidationQuantizedFixture< CLTensor, CLAccessor, CLDirectConvolutionLayer, T, true >
 
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 CLElementwiseMaxFloatFixture = ElementwiseMaxValidationFloatFixture< CLTensor, CLAccessor, CLElementwiseMax, T >
 
template<typename T >
using CLElementwiseMaxBroadcastFloatFixture = ElementwiseMaxBroadcastValidationFloatFixture< 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 CLElementwiseMinFloatFixture = ElementwiseMinValidationFloatFixture< CLTensor, CLAccessor, CLElementwiseMin, T >
 
template<typename T >
using CLElementwiseMinBroadcastFloatFixture = ElementwiseMinBroadcastValidationFloatFixture< CLTensor, CLAccessor, CLElementwiseMin, T >
 
template<typename T >
using CLElementwisePowerFloatFixture = ElementwisePowerValidationFloatFixture< CLTensor, CLAccessor, CLElementwisePower, T >
 
template<typename T >
using CLElementwisePowerBroadcastFloatFixture = ElementwisePowerBroadcastValidationFloatFixture< 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 CLElementwiseSquaredDiffFloatFixture = ElementwiseSquaredDiffValidationFloatFixture< CLTensor, CLAccessor, CLElementwiseSquaredDiff, T >
 
template<typename T >
using CLElementwiseSquaredDiffBroadcastFloatFixture = ElementwiseSquaredDiffBroadcastValidationFloatFixture< CLTensor, CLAccessor, CLElementwiseSquaredDiff, T >
 
template<typename T >
using CLExpLayerFixture = ExpValidationFixture< CLTensor, CLAccessor, CLExpLayer, 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 CLFFTConvolutionLayerMixedDataLayoutFixture = FFTConvolutionValidationFixture< CLTensor, CLAccessor, CLFFTConvolutionLayer, T, true >
 
template<typename T >
using CLFillFixture = FillFixture< CLTensor, CLAccessor, CLFill, 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 CLFullyConnectedLayerMixedDataLayoutFixture = FullyConnectedLayerValidationFixture< CLTensor, CLAccessor, CLFullyConnectedLayer, T, true >
 
template<typename T >
using CLFullyConnectedLayerDynamicWeightsFixture = FullyConnectedWithDynamicWeightsFixture< CLTensor, CLAccessor, CLFullyConnectedLayer, T >
 
template<typename T >
using CLFullyConnectedLayerQuantizedFixture = FullyConnectedLayerValidationQuantizedFixture< CLTensor, CLAccessor, CLFullyConnectedLayer, T >
 
template<typename T >
using CLFullyConnectedLayerQuantizedMixedDataLayoutFixture = FullyConnectedLayerValidationQuantizedFixture< CLTensor, CLAccessor, CLFullyConnectedLayer, T, true >
 
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 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 CLGEMMLowpMatrixMultiplyCoreFusedOffsetOutputUint8Fixture = GEMMLowpMatrixMultiplyCoreFusedOffsetOutputGenericValidationFixture< CLTensor, CLAccessor, CLGEMMLowpMatrixMultiplyCore >
 
using CLGEMMLowpMatrixMultiplyCoreFusedOffsetOutputOutput3DUint8Fixture = GEMMLowpMatrixMultiplyCoreFusedOffsetOutputGenericValidationFixture< CLTensor, CLAccessor, CLGEMMLowpMatrixMultiplyCore, false, true >
 
using CLGEMMLowpQuantizeDownInt32ScaleFixture = GEMMLowpQuantizeDownInt32ToUint8ScaleValidationFixture< CLTensor, CLAccessor, CLGEMMLowpOutputStage >
 
using CLGEMMLowpMatrixMultiplyNative = CLSynthetizeOperator< opencl::kernels::ClGemmLowpMatrixMultiplyNativeKernel >
 
using CLGEMMLowpMatrixMultiplyNativeFixture = GEMMLowpMatrixMultiplyNativeValidationFixture< CLTensor, CLAccessor, CLGEMMLowpMatrixMultiplyNative >
 
using CLGEMMLowpMatrixMultiplyNative3DFixture = GEMMLowpMatrixMultiplyNative3DValidationFixture< CLTensor, CLAccessor, CLGEMMLowpMatrixMultiplyNative >
 
using CLGEMMReshapeLHSMatrix = CLSynthetizeOperator< opencl::kernels::ClGemmReshapeLhsMatrixKernel >
 
using CLGEMMReshapeRHSMatrix = CLSynthetizeOperator< opencl::kernels::ClGemmReshapeRhsMatrixKernel >
 
using CLGEMMLowpMatrixMultiplyReshaped = CLSynthetizeOperator< opencl::kernels::ClGemmLowpMatrixMultiplyReshapedKernel >
 
using CLGEMMLowpMatrixMultiplyReshapedFixture = GEMMLowpMatrixMultiplyReshapedValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeLHSMatrix, CLGEMMReshapeRHSMatrix, CLGEMMLowpMatrixMultiplyReshaped >
 
using CLGEMMLowpMatrixMultiplyReshaped3DFixture = GEMMLowpMatrixMultiplyReshaped3DValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeLHSMatrix, CLGEMMReshapeRHSMatrix, CLGEMMLowpMatrixMultiplyReshaped >
 
using CLGEMMLowpMatrixMultiplyReshapedOnlyRHS = CLSynthetizeOperator< opencl::kernels::ClGemmLowpMatrixMultiplyReshapedOnlyRhsKernel >
 
using CLGEMMLowpMatrixMultiplyReshapedOnlyRHSFixture = GEMMLowpMatrixMultiplyReshapedOnlyRHSValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeRHSMatrix, CLGEMMLowpMatrixMultiplyReshapedOnlyRHS >
 
using CLGEMMLowpMatrixMultiplyReshapedOnlyRHS3DFixture = GEMMLowpMatrixMultiplyReshapedOnlyRHS3DValidationFixture< CLTensor, CLAccessor, CLGEMMReshapeRHSMatrix, CLGEMMLowpMatrixMultiplyReshapedOnlyRHS >
 
using CLGEMMMatrixMultiplyNative = CLSynthetizeOperator< ClGemmMatrixMultiplyKernel >
 
template<typename T >
using CLGEMMMatrixMultiplyNativeFixture = GEMMMatrixMultiplyValidationFixture< CLTensor, CLAccessor, T, CLGEMMMatrixMultiplyNative >
 
template<typename T >
using CLGEMMMatrixMultiplyNative3DFixture = GEMMMatrixMultiply3DValidationFixture< CLTensor, CLAccessor, T, CLGEMMMatrixMultiplyNative >
 
using CLGEMMMatrixMultiplyReshaped = CLSynthetizeOperator< 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 >
 
template<typename T >
using CLGEMMMatrixMultiplyReshapedMixedPrecisionFixture = GEMMMatrixMultiplyReshapedValidationFixture< CLTensor, CLAccessor, T, CLGEMMReshapeLHSMatrix, CLGEMMReshapeRHSMatrix, CLGEMMMatrixMultiplyReshaped, true >
 
template<typename T >
using CLGEMMMatrixMultiplyReshaped3DMixedPrecisionFixture = GEMMMatrixMultiplyReshaped3DValidationFixture< CLTensor, CLAccessor, T, CLGEMMReshapeLHSMatrix, CLGEMMReshapeRHSMatrix, CLGEMMMatrixMultiplyReshaped, true >
 
using CLGEMMMatrixMultiplyReshapedOnlyRHS = CLSynthetizeOperator< 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 CLHeightConcatenateLayerFixture = ConcatenateLayerValidationFixture< CLTensor, ICLTensor, CLAccessor, CLConcatenateLayer, T >
 
using ClIm2Col = ClSynthetizeOperatorWithBorder< opencl::kernels::ClIm2ColKernel >
 
template<typename T >
using ClIm2ColFixture = Im2ColOpValidationFixture< CLTensor, CLAccessor, ClIm2Col, T, true >
 
template<typename T >
using CLInstanceNormalizationLayerFixture = InstanceNormalizationLayerValidationFixture< CLTensor, CLAccessor, CLInstanceNormalizationLayer, T >
 
template<typename T >
using CLL2NormalizeLayerFixture = L2NormalizeLayerValidationFixture< CLTensor, CLAccessor, CLL2NormalizeLayer, T >
 
template<typename T >
using CLLogLayerFixture = LogValidationFixture< CLTensor, CLAccessor, CLLogLayer, T >
 
template<typename T >
using CLLogSoftmaxLayerFixture = SoftmaxValidationFixture< CLTensor, CLAccessor, CLLogSoftmaxLayer, T, true >
 
template<typename T >
using CLLSTMLayerFixture = LSTMLayerValidationFixture< CLTensor, CLAccessor, CLLSTMLayer, LSTMParams< ICLTensor >, T >
 
template<typename T >
using CLMaxUnpoolingLayerFixture = MaxUnpoolingLayerValidationFixture< CLTensor, CLAccessor, CLPoolingLayer, CLMaxUnpoolingLayer, T >
 
template<typename T >
using CLMeanStdDevNormalizationLayerFixture = MeanStdDevNormalizationLayerValidationFixture< CLTensor, CLAccessor, CLMeanStdDevNormalizationLayer, T >
 
template<typename T >
using CLNegLayerFixture = NegValidationFixture< CLTensor, CLAccessor, CLNegLayer, 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 CLPaddingFixture = PaddingFixture< CLTensor, CLAccessor, CLPadLayer, T >
 
template<typename T >
using CLPixelWiseMultiplicationToF16Fixture = PixelWiseMultiplicationValidationFloatFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, half_float::half >
 
template<typename T >
using CLPixelWiseMultiplicationToF32Fixture = PixelWiseMultiplicationValidationFloatFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, float >
 
template<typename T >
using CLPixelWiseMultiplicationToF32BroadcastFixture = PixelWiseMultiplicationBroadcastValidationFloatFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, float >
 
template<typename T >
using CLPixelWiseMultiplicationIntegerFixture = PixelWiseMultiplicationValidationIntegerFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, int >
 
template<typename T >
using CLPixelWiseMultiplicationQuantizedFixture = PixelWiseMultiplicationValidationQuantizedFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, T >
 
using CLPixelWiseMultiplicationQSYMM16ToS32Fxture = PixelWiseMultiplicationValidationQuantizedFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, int16_t, int16_t, int32_t >
 
template<typename T >
using CLPixelWiseMultiplicationQuantizedBroadcastFixture = PixelWiseMultiplicationBroadcastValidationQuantizedFixture< CLTensor, CLAccessor, CLPixelWiseMultiplication, T, T >
 
template<typename T >
using CLPoolingLayerFixture = PoolingLayerValidationFixture< CLTensor, CLAccessor, CLPoolingLayer, T >
 
template<typename T >
using CLPoolingLayerMixedDataLayoutFixture = PoolingLayerValidationFixture< CLTensor, CLAccessor, CLPoolingLayer, T, true >
 
template<typename T >
using CLSpecialPoolingLayerFixture = SpecialPoolingLayerValidationFixture< CLTensor, CLAccessor, CLPoolingLayer, T >
 
template<typename T >
using CLMixedPrecesionPoolingLayerFixture = PoolingLayerValidationMixedPrecisionFixture< CLTensor, CLAccessor, CLPoolingLayer, T >
 
template<typename T >
using CLPoolingLayerIndicesFixture = PoolingLayerIndicesValidationFixture< CLTensor, CLAccessor, CLPoolingLayer, T >
 
template<typename T >
using CLPoolingLayerQuantizedMixedDataLayoutFixture = PoolingLayerValidationQuantizedFixture< CLTensor, CLAccessor, CLPoolingLayer, T, true >
 
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 CLQLSTMLayerNormalizationFixture = QLSTMLayerNormalizationValidationFixture< CLTensor, CLAccessor, CLQLSTMLayerNormalization, T >
 
template<typename T >
using CLQuantizationLayerQASYMM8Fixture = QuantizationValidationFixture< CLTensor, CLAccessor, CLQuantizationLayer, T, uint8_t >
 
template<typename T >
using CLQuantizationLayerQASYMM8_SIGNEDFixture = QuantizationValidationFixture< CLTensor, CLAccessor, CLQuantizationLayer, T, int8_t >
 
template<typename T >
using CLQuantizationLayerQASYMM16Fixture = QuantizationValidationFixture< CLTensor, CLAccessor, CLQuantizationLayer, T, uint16_t >
 
template<typename T >
using CLQuantizationLayerQASYMM8_SIGNEDGenFixture = QuantizationValidationGenericFixture< CLTensor, CLAccessor, CLQuantizationLayer, T, int8_t >
 
template<typename T >
using CLQuantizationLayerQASYMM16GenFixture = QuantizationValidationGenericFixture< CLTensor, CLAccessor, CLQuantizationLayer, T, uint16_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 CLRemapLayoutFixture = RemapValidationMixedLayoutFixture< 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 >
 
using CLROIAlignLayerFloatFixture = ROIAlignLayerFixture< CLTensor, CLAccessor, CLROIAlignLayer, float, float >
 
using CLROIAlignLayerHalfFixture = ROIAlignLayerFixture< CLTensor, CLAccessor, CLROIAlignLayer, half, half >
 
using CLROIPoolingLayerFloatFixture = ROIPoolingLayerFixture< CLTensor, CLAccessor, CLROIPoolingLayer, float >
 
template<typename T >
using CLRoundLayerFixture = RoundValidationFixture< CLTensor, CLAccessor, CLRoundLayer, T >
 
template<typename T >
using CLRsqrtLayerFixture = RsqrtValidationFixture< CLTensor, CLAccessor, CLRsqrtLayer, T >
 
template<typename T >
using CLScaleMixedDataLayoutFixture = ScaleValidationFixture< CLTensor, CLAccessor, CLScale, T, true >
 
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 >
 
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 CLSplitShapesFixture = SplitShapesFixture< 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 CLTileFixture = TileValidationFixture< CLTensor, CLAccessor, CLTile, T >
 
template<typename T >
using CLTransposeFixture = TransposeValidationFixture< CLTensor, CLAccessor, CLTranspose, T >
 
using BlobMemoryManagementService = MemoryManagementService< CLBufferAllocator, BlobLifetimeManager, PoolManager, MemoryManagerOnDemand >
 
using CLDynamicTensorType3SingleFunction = DynamicTensorType3SingleFunction< CLTensor, CLAccessor, BlobMemoryManagementService, CLL2NormLayerWrapper >
 
using CLDynamicTensorType3ComplexFunction = DynamicTensorType3ComplexFunction< CLTensor, CLAccessor, BlobMemoryManagementService, CLConvolutionLayer >
 
using CLDynamicTensorType2PipelineFunction = DynamicTensorType2PipelineFunction< CLTensor, CLAccessor, BlobMemoryManagementService, CLConvolutionLayer >
 
using CLBlobMemoryManagerSimpleWithinFunctionLevelFixture = BlobMemoryManagerSimpleTestCaseFixture< CLTensor, CLAccessor, CLBufferAllocator, CLFullyConnectedLayer >
 
using CLWeightsRetentionFixture = WeightsRetentionReconfigureTestCaseFixture< CLTensor, CLAccessor, CLFullyConnectedLayer >
 
template<typename T >
using CLUnstackFixture = UnstackValidationFixture< CLTensor, ICLTensor, CLAccessor, CLUnstack, T >
 
using ClWeightsReshape = ClSynthetizeOperatorWithBorder< opencl::kernels::ClWeightsReshapeKernel >
 
template<typename T >
using ClWeightsReshapeFixture = WeightsReshapeOpValidationFixture< CLTensor, CLAccessor, ClWeightsReshape, T >
 
template<typename T >
using CLWidthConcatenateLayerFixture = ConcatenateLayerValidationFixture< CLTensor, ICLTensor, CLAccessor, CLConcatenateLayer, T >
 
using CLWinogradConvolutionLayerFastMathFixture = WinogradConvolutionLayerFastMathValidationFixture< CLTensor, CLAccessor, CLWinogradConvolutionLayer, float >
 
using CLWinogradConvolutionLayerFastMathMixedDataLayoutFixture = WinogradConvolutionLayerFastMathValidationFixture< CLTensor, CLAccessor, CLWinogradConvolutionLayer, float, float, true, true >
 
using CPPNonMaxSuppressionFixture = NMSValidationFixture< Tensor, Accessor, CPPNonMaximumSuppression >
 
template<typename T >
using CPPPermuteFixture = PermuteValidationFixture< Tensor, Accessor, CPPPermute, 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 NEArithmeticAdditionQuantizedBroadcastFixture = ArithmeticAdditionValidationQuantizedBroadcastFixture< Tensor, Accessor, NEArithmeticAddition, T >
 
template<typename T >
using NEArithmeticSubtractionFixture = ArithmeticSubtractionValidationFixture< Tensor, Accessor, NEArithmeticSubtraction, T >
 
using NEArithmeticSubtractionQASYMM8SignedFixture = ArithmeticSubtractionValidationQuantizedFixture< Tensor, Accessor, NEArithmeticSubtraction, int8_t >
 
using NEArithmeticSubtractionQASYMM8SignedBroadcastFixture = ArithmeticSubtractionValidationQuantizedBroadcastFixture< Tensor, Accessor, NEArithmeticSubtraction, int8_t >
 
using NEArithmeticSubtractionQSYMM16Fixture = ArithmeticSubtractionValidationQuantizedFixture< Tensor, Accessor, NEArithmeticSubtraction, int16_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 NEBoundingBoxTransformFixture = BoundingBoxTransformFixture< Tensor, Accessor, NEBoundingBoxTransform, 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 NECastToQASYMM8_SIGNEDFixture = CastValidationFixture< Tensor, Accessor, NECast, T, int8_t >
 
template<typename T >
using NEChannelShuffleLayerFixture = ChannelShuffleLayerValidationFixture< Tensor, Accessor, NEChannelShuffleLayer, T >
 
using CpuCol2Im = NESynthetizeFunction< cpu::kernels::CpuCol2ImKernel >
 
template<typename T >
using NEComparisonFixture = ComparisonValidationFixture< Tensor, Accessor, NEElementwiseComparison, T >
 
template<typename T >
using NEComparisonQuantizedBroadcastFixture = ComparisonQuantizedBroadcastValidationFixture< Tensor, Accessor, NEElementwiseComparison, T >
 
template<typename T >
using NEConvertFullyConnectedWeightsFixture = ConvertFullyConnectedWeightsValidationFixture< Tensor, Accessor, NEConvertFullyConnectedWeights, T >
 
template<typename T >
using NEWinogradConvolutionLayerMixedDataLayoutFixture = WinogradConvolutionLayerFastMathValidationFixture< Tensor, Accessor, NEWinogradConvolutionLayer, T, T, true, true >
 
template<typename T >
using NEWinogradConvolutionLayerNoBiasFixture = WinogradConvolutionLayerFastMathValidationFixture< Tensor, Accessor, NEWinogradConvolutionLayer, T, T, false >
 
template<typename T >
using NEGEMMConvolutionLayerMixedDataLayoutFixture = ConvolutionValidationFixture< Tensor, Accessor, NEConvolutionLayer, T, true >
 
template<typename T >
using NEGEMMConvolutionLayerQuantizedMixedDataLayoutFixture = ConvolutionValidationQuantizedFixture< Tensor, Accessor, NEConvolutionLayer, T, true >
 
template<typename T >
using NEGEMMConvolutionLayerQuantizedPerChannelFixture = ConvolutionValidationQuantizedPerChannelFixture< Tensor, Accessor, NEConvolutionLayer, T, int8_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 NEDeconvolutionLayerAsymmFixture3x3 = DeconvolutionValidationAsymmFixture< Tensor, Accessor, NEDeconvolutionLayer, T, 3, 3 >
 
template<typename T >
using NEDeconvolutionLayerAsymmFixture9x9 = DeconvolutionValidationAsymmFixture< Tensor, Accessor, NEDeconvolutionLayer, T, 9, 9 >
 
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 NEDeconvolutionLayerQuantizedPerChannelFixture4x4 = DeconvolutionValidationQuantizedPerChannelFixture< Tensor, Accessor, NEDeconvolutionLayer, T, int8_t, 4, 4 >
 
template<typename T >
using NEDeconvolutionLayerQuantizedPerChannelFixture3x3 = DeconvolutionValidationQuantizedPerChannelFixture< Tensor, Accessor, NEDeconvolutionLayer, T, int8_t, 3, 3 >
 
template<typename T >
using NEDeconvolutionLayerQuantizedPerChannelFixture1x1 = DeconvolutionValidationQuantizedPerChannelFixture< Tensor, Accessor, NEDeconvolutionLayer, T, int8_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 NEDepthConvertLayerToBF16Fixture = DepthConvertLayerValidationFixture< Tensor, Accessor, NEDepthConvertLayer, T, bfloat16 >
 
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 NEDepthwiseConvolutionLayerMixedDataLayoutFixture = DepthwiseConvolutionLayerValidationFixture< Tensor, Accessor, NEDepthwiseConvolutionLayer, T, true >
 
template<typename T >
using NEDepthwiseConvolutionLayerQuantizedMixedDataLayoutFixture = DepthwiseConvolutionLayerValidationQuantizedFixture< Tensor, Accessor, NEDepthwiseConvolutionLayer, T, true >
 
using NEDepthwiseConvolutionLayerQuantizedSymmetricPerChannelFixture = DepthwiseConvolutionLayerValidationQuantizedPerChannelFixture< Tensor, Accessor, NEDepthwiseConvolutionLayer, uint8_t, int8_t >
 
using CpuDepthwiseConvolutionNative = NESynthetizeFunctionWithZeroConstantKernelBorder< cpu::kernels::CpuDepthwiseConv2dNativeKernel >
 
template<typename T >
using CpuDepthwiseConvolutionNativeFixture = DepthwiseConvolutionLayerNativeValidationFixture< Tensor, Accessor, CpuDepthwiseConvolutionNative, T >
 
template<typename T >
using NEDequantizationLayerFixture = DequantizationValidationFixture< Tensor, Accessor, NEDequantizationLayer, T >
 
template<typename T >
using NEDirectConvolutionLayerFixture = DirectConvolutionValidationFixture< Tensor, Accessor, NEDirectConvolutionLayer, T >
 
template<typename T >
using NEDirectConvolutionLayerMixedDataLayoutFixture = DirectConvolutionValidationFixture< Tensor, Accessor, NEDirectConvolutionLayer, T, true >
 
template<typename T >
using NEAbsLayerFixture = AbsValidationFixture< Tensor, Accessor, NEAbsLayer, T >
 
template<typename T >
using NEElementwiseDivisionFixture = ArithmeticDivisionValidationFixture< Tensor, Accessor, NEElementwiseDivision, T >
 
template<typename T >
using CpuElementwiseDivisionDynamicShapeFixture = ArithmeticDivisionDynamicShapeValidationFixture< Tensor, Accessor, NEElementwiseDivision, T >
 
template<typename T >
using CpuElementwiseDivisionBroadcastDynamicShapeFixture = ArithmeticDivisionBroadcastDynamicShapeValidationFixture< Tensor, Accessor, NEElementwiseDivision, T >
 
template<typename T >
using NEElementwiseDivisionBroadcastFixture = ArithmeticDivisionBroadcastValidationFixture< 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 = NegValidationInPlaceFixture< 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 CpuRsqrtDynamicShapeFixture = RsqrtDynamicShapeValidationFixture< 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 NEFFT1DFixture = FFTValidationFixture< Tensor, Accessor, NEFFT1D, FFT1DInfo, T >
 
template<typename T >
using NEFFT2DFixture = FFTValidationFixture< Tensor, Accessor, NEFFT2D, FFT2DInfo, T >
 
template<typename T >
using NEFFTConvolutionLayerMixedDataLayoutFixture = FFTConvolutionValidationFixture< Tensor, Accessor, NEFFTConvolutionLayer, T, true >
 
template<typename T >
using NEFillFixture = FillFixture< Tensor, Accessor, NEFill, 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 NEFullyConnectedLayerMixedDataLayoutFixture = FullyConnectedLayerValidationFixture< Tensor, Accessor, NEFullyConnectedLayer, T, true >
 
template<typename T >
using NEFullyConnectedLayerQuantizedFixture = FullyConnectedLayerValidationQuantizedFixture< Tensor, Accessor, NEFullyConnectedLayer, T >
 
template<typename T >
using NEFullyConnectedLayerQuantizedMixedDataLayoutFixture = FullyConnectedLayerValidationQuantizedFixture< Tensor, Accessor, NEFullyConnectedLayer, T, true >
 
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 >
 
using CpuGemmTranspose1xW = NESynthetizeFunctionWithZeroConstantKernelBorder< cpu::kernels::CpuGemmTranspose1xWKernel >
 
using CpuGemmTranspose1xWFixture = GEMMTranspose1xWValidationFixture< Tensor, Accessor, CpuGemmTranspose1xW, uint32_t >
 
using CpuGemmInterleave4x4Fixture = GEMMInterleave4x4ValidationFixture< Tensor, Accessor, CpuGemmInterleave4x4, uint32_t >
 
template<typename T >
using NEGEMMFixtureDisabledC = GEMMValidationFixture< Tensor, Accessor, NEGEMM, T, true >
 
using NEGEMMLowpMatrixMultiplyCoreFixture = GEMMLowpMatrixMultiplyCoreValidationFixture< Tensor, Accessor, NEGEMMLowpMatrixMultiplyCore >
 
using NEGEMMLowpMatrixMultiplyCoreFusedOffsetOutputFixture = GEMMLowpMatrixMultiplyCoreFusedOffsetOutputValidationFixture< Tensor, Accessor, NEGEMMLowpMatrixMultiplyCore >
 
template<typename T >
using NEComputeAllAnchorsFixture = ComputeAllAnchorsFixture< Tensor, Accessor, NEComputeAllAnchors, T >
 
template<typename T >
using NEGlobalPoolingLayerFixture = GlobalPoolingLayerValidationFixture< Tensor, Accessor, NEPoolingLayer, T >
 
template<typename T >
using NEHeightConcatenateLayerFixture = ConcatenateLayerValidationFixture< Tensor, ITensor, Accessor, NEConcatenateLayer, T >
 
using CpuIm2Col = NESynthetizeFunctionWithZeroConstantKernelBorder< cpu::kernels::CpuIm2ColKernel >
 
template<typename T >
using CpuIm2ColFixture = Im2ColOpValidationFixture< Tensor, Accessor, CpuIm2Col, T, false >
 
template<typename T >
using NEInstanceNormalizationLayerFixture = InstanceNormalizationLayerValidationFixture< Tensor, Accessor, NEInstanceNormalizationLayer, T >
 
template<typename T >
using NEL2NormalizeLayerFixture = L2NormalizeLayerValidationFixture< Tensor, Accessor, NEL2NormalizeLayer, T >
 
template<typename T >
using NELogicalAndFixture = LogicalAndValidationFixture< Tensor, Accessor, NELogicalAnd, T >
 
template<typename T >
using NELogSoftmaxLayerFixture = SoftmaxValidationFixture< Tensor, Accessor, NELogSoftmaxLayer, T, true >
 
template<typename T >
using NELSTMLayerFixture = LSTMLayerValidationFixture< Tensor, Accessor, NELSTMLayer, LSTMParams< ITensor >, T >
 
template<typename T >
using NEMaxUnpoolingLayerFixture = MaxUnpoolingLayerValidationFixture< Tensor, Accessor, NEPoolingLayer, NEMaxUnpoolingLayer, T >
 
template<typename T >
using NEMeanStdDevNormalizationLayerFixture = MeanStdDevNormalizationLayerValidationFixture< Tensor, Accessor, NEMeanStdDevNormalizationLayer, T >
 
template<typename T >
using NENormalizationLayerFixture = NormalizationValidationFixture< Tensor, Accessor, NENormalizationLayer, T >
 
template<typename T >
using NEPaddingFixture = PaddingFixture< Tensor, Accessor, NEPadLayer, T >
 
template<typename T >
using NEPermuteFixture = PermuteValidationFixture< Tensor, Accessor, NEPermute, T >
 
using NEPixelWiseMultiplicationQASYMM8Fixture = PixelWiseMultiplicationValidationQuantizedFixture< Tensor, Accessor, NEPixelWiseMultiplication, uint8_t, uint8_t >
 
using NEPixelWiseMultiplicationQASYMM8SignedFixture = PixelWiseMultiplicationValidationQuantizedFixture< Tensor, Accessor, NEPixelWiseMultiplication, int8_t, int8_t >
 
using NEPixelWiseMultiplicationQSYMM16Fixture = PixelWiseMultiplicationValidationQuantizedFixture< Tensor, Accessor, NEPixelWiseMultiplication, int16_t, int16_t >
 
using NEPixelWiseMultiplicationQSYMM16ToS32Fixture = PixelWiseMultiplicationValidationQuantizedFixture< Tensor, Accessor, NEPixelWiseMultiplication, int16_t, int16_t, int32_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 NEPixelWiseMultiplicationToS32Fixture = PixelWiseMultiplicationValidationFixture< Tensor, Accessor, NEPixelWiseMultiplication, T, int32_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 >
 
using NEPixelWiseMultiplicationU8U8ToS16Fixture = PixelWiseMultiplicationValidationFixture< Tensor, Accessor, NEPixelWiseMultiplication, uint8_t, uint8_t, int16_t >
 
template<typename T >
using NEPixelWiseMultiplicationBroadcastFixture = PixelWiseMultiplicationBroadcastValidationFixture< Tensor, Accessor, NEPixelWiseMultiplication, T, T >
 
using NEPixelWiseMultiplicationBroadcastQASYMM8Fixture = PixelWiseMultiplicationBroadcastValidationQuantizedFixture< Tensor, Accessor, NEPixelWiseMultiplication, uint8_t, uint8_t >
 
using NEPixelWiseMultiplicationBroadcastQASYMM8SignedFixture = PixelWiseMultiplicationBroadcastValidationQuantizedFixture< Tensor, Accessor, NEPixelWiseMultiplication, int8_t, int8_t >
 
template<typename T >
using NEPoolingLayerIndicesFixture = PoolingLayerIndicesValidationFixture< Tensor, Accessor, NEPoolingLayer, T >
 
template<typename T >
using NEPoolingLayerFixture = PoolingLayerValidationFixture< Tensor, Accessor, NEPoolingLayer, T >
 
template<typename T >
using NEPoolingLayerMixedDataLayoutFixture = PoolingLayerValidationFixture< Tensor, Accessor, NEPoolingLayer, T, true >
 
template<typename T >
using NESpecialPoolingLayerFixture = SpecialPoolingLayerValidationFixture< Tensor, Accessor, NEPoolingLayer, T >
 
template<typename T >
using NEPoolingLayerQuantizedMixedDataLayoutFixture = PoolingLayerValidationQuantizedFixture< Tensor, Accessor, NEPoolingLayer, T, true >
 
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 NEQLSTMLayerNormalizationFixture = QLSTMLayerNormalizationValidationFixture< Tensor, Accessor, NEQLSTMLayerNormalization, T >
 
template<typename T >
using NEQuantizationLayerQASYMM8Fixture = QuantizationValidationFixture< Tensor, Accessor, NEQuantizationLayer, T, uint8_t >
 
template<typename T >
using NEQuantizationLayerQASYMM8SignedFixture = QuantizationValidationFixture< Tensor, Accessor, NEQuantizationLayer, T, int8_t >
 
template<typename T >
using NEQuantizationLayerQASYMM16Fixture = QuantizationValidationFixture< Tensor, Accessor, NEQuantizationLayer, T, uint16_t >
 
template<typename T >
using NEQuantizationLayerQASYMM8_SIGNEDGenFixture = QuantizationValidationGenericFixture< Tensor, Accessor, NEQuantizationLayer, T, int8_t >
 
template<typename T >
using NEQuantizationLayerQASYMM16GenFixture = QuantizationValidationGenericFixture< Tensor, Accessor, NEQuantizationLayer, T, uint16_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 >
 
using NEROIAlignLayerFloatFixture = ROIAlignLayerFixture< Tensor, Accessor, NEROIAlignLayer, float, float >
 
using NEROIPoolingLayerFloatFixture = ROIPoolingLayerFixture< Tensor, Accessor, NEROIPoolingLayer, float >
 
template<typename T >
using NEScaleFixture = ScaleValidationFixture< Tensor, Accessor, NEScale, T >
 
template<typename T >
using NEScaleMixedDataLayoutFixture = ScaleValidationFixture< Tensor, Accessor, NEScale, T, true >
 
template<typename T >
using NEScaleQuantizedFixture = ScaleValidationQuantizedFixture< Tensor, Accessor, NEScale, T >
 
template<typename T >
using NEScaleQuantizedMixedDataLayoutFixture = ScaleValidationQuantizedFixture< Tensor, Accessor, NEScale, T, true >
 
template<typename T >
using NESelectFixture = SelectValidationFixture< Tensor, Accessor, NESelect, T >
 
template<typename T >
using NESliceFixture = SliceFixture< Tensor, Accessor, NESlice, 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 NESplitShapesFixture = SplitShapesFixture< 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 NETileFixture = TileValidationFixture< Tensor, Accessor, NETile, T >
 
template<typename T >
using NETransposeFixture = TransposeValidationFixture< Tensor, Accessor, NETranspose, T >
 
using OffsetMemoryManagementService = MemoryManagementService< Allocator, OffsetLifetimeManager, PoolManager, MemoryManagerOnDemand >
 
using NEDynamicTensorType3SingleFunction = DynamicTensorType3SingleFunction< Tensor, Accessor, OffsetMemoryManagementService, NENormLayerWrapper >
 
using NEDynamicTensorType3ComplexFunction = DynamicTensorType3ComplexFunction< Tensor, Accessor, OffsetMemoryManagementService, NEConvolutionLayer >
 
using NEDynamicTensorType2PipelineFunction = DynamicTensorType2PipelineFunction< Tensor, Accessor, OffsetMemoryManagementService, NEConvolutionLayer >
 
template<typename T >
using NEUnstackFixture = UnstackValidationFixture< Tensor, ITensor, Accessor, NEUnstack, T >
 
template<typename T >
using NEWidthConcatenateLayerFixture = ConcatenateLayerValidationFixture< Tensor, ITensor, Accessor, NEConcatenateLayer, 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 () FIXTURE_DATA_TEST_CASE(RunSmall = ActivationValidationQuantizedFixture<CLTensor, CLAccessor, CLActivationLayer, T>
 [CLActivationLayer Test snippet] 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 (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, true, true, true, false, false, true, true, false })), input_info, output_info, act_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLActivationLayerFixture< half >, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), ActivationDataset), framework::dataset::make("DataType", DataType::F16)))
 [CLActivationLayerFixture snippet] More...
 
 combine (combine(datasets::SmallShapes(), ActivationDataset), framework::dataset::make("DataType", DataType::F32)))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLActivationLayerQuantizedFixture< uint8_t >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), QuantizedActivationDataset8), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) })))
 
 combine (combine(combine(datasets::SmallShapes(), QuantizedActivationDataset8), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 10.0f) })))
 
 combine (combine(combine(datasets::SmallShapes(), QuantizedActivationDataset16), 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), TensorInfo(TensorShape(32U, 16U, 16U, 2U), 1, DataType::F32) }), framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(27U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 3U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 2U), 1, DataType::S32), TensorInfo(TensorShape(32U, 16U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 16U, 1U, 2U), 1, DataType::U32) })), framework::dataset::make("Axis", { 4, 0, 2, 0, 2 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MAX, ReductionOperation::ARG_IDX_MAX, ReductionOperation::ARG_IDX_MAX, ReductionOperation::MEAN_SUM, ReductionOperation::ARG_IDX_MAX })), framework::dataset::make("Expected", { false, false, true, false, false })), input_info, output_info, axis, operation, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArgMinMaxValidationFixture< int32_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(ArgMinMaxSmallDataset, 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 })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArgMinMaxValidationFixture< int32_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(ArgMinMaxLargeDataset, 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(ArgMinMaxSmallDataset, 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(ArgMinMaxLargeDataset, 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(ArgMinMaxSmallDataset, 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(ArgMinMaxLargeDataset, 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 (RunSmall, CLArgMinMaxQuantizedValidationFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(ArgMinMaxSmallDataset, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("Axis", { 0, 1, 2, 3 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MIN, ReductionOperation::ARG_IDX_MAX })), framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f/255.f, 20) })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArgMinMaxQuantizedValidationFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(ArgMinMaxLargeDataset, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("Axis", { 0, 1, 2, 3 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MIN, ReductionOperation::ARG_IDX_MAX })), framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f/255.f, 20) })))
 
 combine (combine(combine(combine(ArgMinMaxSmallDataset, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("Axis", { 0, 1, 2, 3 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MIN, ReductionOperation::ARG_IDX_MAX })), framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f/255.f, 20) })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArgMinMaxQuantizedValidationFixture< int8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(ArgMinMaxLargeDataset, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("Axis", { 0, 1, 2, 3 })), framework::dataset::make("Operation", { ReductionOperation::ARG_IDX_MIN, ReductionOperation::ARG_IDX_MAX })), framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f/255.f, 20) })))
 
 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::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::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::U8), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, false, false})), input1_info, input2_info, output_info, expected)
 
 TEST_CASE (FusedActivation, framework::DatasetMode::ALL)
 Validate fused activation expecting the following behaviours: More...
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticAdditionFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), OutOfPlaceDataSet))
 
 combine (combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::S16)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticAdditionFixture< int16_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::S16)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticAdditionQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::QASYMM8)), 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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLArithmeticAdditionBroadcastQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::SmallShapesBroadcast(), framework::dataset::make("DataType", DataType::QASYMM8)), 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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunTinyBroadcastInPlace, CLArithmeticAdditionBroadcastQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::TinyShapesBroadcastInplace(), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f/255.f, 10) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(1.f/255.f, 10) })), framework::dataset::make("OutQInfo", { QuantizationInfo(1.f/255.f, 10) })), InPlaceDataSet))
 
 combine (combine(combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f/255.f, 10) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f/255.f, 10) })), framework::dataset::make("OutQInfo", { QuantizationInfo(1.f/255.f, 5) })), OutOfPlaceDataSet))
 
 combine (combine(combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::QSYMM16)), 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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticAdditionFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLArithmeticAdditionFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::TinyShapes(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 combine (combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLArithmeticAdditionFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::TinyShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticAdditionFloatFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLArithmeticAdditionBroadcastFloatFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapesBroadcast(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivationBroadcast, CLArithmeticAdditionBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::TinyShapesBroadcast(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunLargeBroadcast, CLArithmeticAdditionBroadcastFloatFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapesBroadcast(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 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(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(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(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, false, false, false})), input1_info, input2_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmallInteger, CLArithmeticDivisionIntegerFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), ArithmeticDivisionS32Dataset), EmptyActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunIntegerWithActivation, CLArithmeticDivisionIntegerFixture, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), ArithmeticDivisionS32Dataset), ActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticDivisionFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), ArithmeticDivisionFP16Dataset), EmptyActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLArithmeticDivisionFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ArithmeticDivisionFP16Dataset), ActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticDivisionFloatFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), ArithmeticDivisionFP32Dataset), EmptyActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLArithmeticDivisionFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ArithmeticDivisionFP32Dataset), ActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticDivisionFloatFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), ArithmeticDivisionFP32Dataset), EmptyActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLArithmeticDivisionBroadcastFloatFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapesBroadcast(), ArithmeticDivisionFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivationBroadcast, CLArithmeticDivisionBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapesBroadcast(), ArithmeticDivisionFP32Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunLargeBroadcast, CLArithmeticDivisionBroadcastFloatFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapesBroadcast(), ArithmeticDivisionFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 TEST_CASE (SingleTensor, framework::DatasetMode::ALL)
 
 TEST_CASE (ValidBroadCast, framework::DatasetMode::ALL)
 
 TEST_CASE (InvalidBroadcastOutput, framework::DatasetMode::ALL)
 
 TEST_CASE (InvalidBroadcastBoth, framework::DatasetMode::ALL)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticSubtractionFixture< uint8_t >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticSubtractionFixture< int16_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::S16)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticSubtractionQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::QASYMM8)), 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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunTinyInPlace, CLArithmeticSubtractionQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::TinyShapes(), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f/255.f, 20) })), framework::dataset::make("Src1QInfo", { QuantizationInfo(5.f/255.f, 20) })), framework::dataset::make("OutQInfo", { QuantizationInfo(5.f/255.f, 20) })), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLArithmeticSubtractionFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLArithmeticSubtractionFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::TinyShapes(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), ActivationFunctionsDataset), InPlaceDataSet))
 
 combine (combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLArithmeticSubtractionFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::TinyShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), ActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLArithmeticSubtractionFloatFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLArithmeticSubtractionBroadcastFloatFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapesBroadcast(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunTinyBroadcastInplace, CLArithmeticSubtractionBroadcastFloatFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::TinyShapesBroadcastInplace(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), InPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivationBroadcast, CLArithmeticSubtractionBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::TinyShapesBroadcast(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunLargeBroadcast, CLArithmeticSubtractionBroadcastFloatFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapesBroadcast(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 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)
 
 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 (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 })))
 
 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 })))
 
 FIXTURE_DATA_TEST_CASE (BoundingBox, CLBoundingBoxTransformQuantizedFixture< uint16_t >, framework::DatasetMode::ALL, combine(combine(combine(DeltaDataset, BboxInfoDataset), framework::dataset::make("DataType", { DataType::QASYMM16 })), framework::dataset::make("DeltasQuantInfo", { QuantizationInfo(1.f/255.f, 127) })))
 
 TEST_SUITE (U8_to_S8) FIXTURE_DATA_TEST_CASE(RunSmall
 
 combine (combine(datasets::SmallShapes(), CastU8toS8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU8toU16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU8toS16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU8toU32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU8toS32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU8toF16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU8toF32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS8toU8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS8toU16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS8toS16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS8toU32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS8toS32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS8toF16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS8toF32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU16toU8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU16toS8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU16toS16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU16toU32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU16toS32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU16toF16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU16toF32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS16toU8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS16toS8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS16toU16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS16toU32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS16toS32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS16toF16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS16toF32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU32toU8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU32toS8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU32toU16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU32toS16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU32toS32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU32toF16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastU32toF32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS32toU8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS32toS8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS32toU16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS32toS16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS32toU32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS32toF16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastS32toF32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF16toU8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF16toS8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF16toU16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF16toS16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF16toU32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF16toS32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF16toF32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF32toU8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF32toS8Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF32toU16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF32toS16Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF32toU32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF32toS32Dataset), datasets::ConvertPolicies()))
 
 combine (combine(datasets::SmallShapes(), CastF32toF16Dataset), datasets::ConvertPolicies()))
 
 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)
 
 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 })))
 
 TEST_CASE (Negative, framework::DatasetMode::ALL)
 Negative tests. More...
 
 FIXTURE_DATA_TEST_CASE (FP32, ClCol2ImFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(framework::dataset::make("InputShape", { TensorShape(8U, 16U, 3U, 1U), TensorShape(17U, 16U, 3U, 1U), TensorShape(7U, 16U, 3U, 1U) }), framework::dataset::make("ConvolvedWidth", 4)), framework::dataset::make("ConvolvedHeight", 4)), framework::dataset::make("Groups", { 1, 3 })), framework::dataset::make("DataType", DataType::F32)))
 Test kernel for single-precision floating point. More...
 
 FIXTURE_DATA_TEST_CASE (F16, ClCol2ImFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(framework::dataset::make("InputShape", TensorShape(17U, 16U, 3U, 1U)), framework::dataset::make("ConvolvedWidth", 4)), framework::dataset::make("ConvolvedHeight", 4)), framework::dataset::make("Groups", 3)), framework::dataset::make("DataType", DataType::F16)))
 Test kernel for half-precision floating point. More...
 
 FIXTURE_DATA_TEST_CASE (QASYMM8, ClCol2ImFixture< uint8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(framework::dataset::make("InputShape", TensorShape(17U, 16U, 3U, 1U)), framework::dataset::make("ConvolvedWidth", 4)), framework::dataset::make("ConvolvedHeight", 4)), framework::dataset::make("Groups", 3)), framework::dataset::make("DataType", DataType::QASYMM8)))
 Test kernel for unsigned asymmetric quantized type. More...
 
 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)
 
 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 (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), TensorInfo(TensorShape(17U, 31U, 2U), 1, DataType::QASYMM8_SIGNED), }), 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), TensorInfo(TensorShape(5U, 5U, 2U, 19U), 1, DataType::QASYMM8_SIGNED), })), 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), TensorInfo(TensorShape(17U, 31U, 19U), 1, DataType::QASYMM8_SIGNED), })), 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), 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, 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), Size2D(2U, 1U), })), framework::dataset::make("EnableFastMath", { false, false, false, false, false, false, true, true, true })), framework::dataset::make("Expected",{ ConvolutionMethod::GEMM, ConvolutionMethod::GEMM, ConvolutionMethod::GEMM, ConvolutionMethod::WINOGRAD, ConvolutionMethod::GEMM, ConvolutionMethod::GEMM, ConvolutionMethod::WINOGRAD, ConvolutionMethod::GEMM, ConvolutionMethod::GEMM, })), input_info, weights_info, output_info, conv_info, gpu_target, dilation, enable_fast_math, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMConvolutionLayerFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::SmallConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsSmallDataset))
 
 combine (combine(combine(combine(datasets::SmallConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsSmallDataset))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLGEMMConvolutionLayerMixedDataLayoutFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(combine(combine(combine(framework::dataset::make("Input", TensorShape(23U, 27U, 5U)), framework::dataset::make("Weights", TensorShape(3U, 3U, 5U, 2U))), framework::dataset::make("Bias", TensorShape(2U))), framework::dataset::make("Output", TensorShape(11U, 25U, 2U))), framework::dataset::make("PadStrideInfo", PadStrideInfo(2, 1, 0, 0))), framework::dataset::make("Dilation", Size2D(1, 1))), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsSmallDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmallCases, CLGEMMConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(SmallConvolutionLayerDatasetCases(), 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 (RunSmall, CLGEMMConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::SmallConvolutionLayerDataset(), 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 (RunMixedDataLayout, CLGEMMConvolutionLayerQuantizedMixedDataLayoutFixture< uint8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(framework::dataset::make("Input", TensorShape(23U, 27U, 5U)), framework::dataset::make("Weights", TensorShape(3U, 3U, 5U, 2U))), framework::dataset::make("Bias", TensorShape(2U))), framework::dataset::make("Output", TensorShape(11U, 25U, 2U))), framework::dataset::make("PadStrideInfo", PadStrideInfo(2, 1, 0, 0))), framework::dataset::make("Dilation", Size2D(1, 1))), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), QuantizationData), QuantizedActivationFunctionsSmallDataset))
 
 combine (combine(combine(combine(combine(datasets::SmallConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), QuantizationData), QuantizedActivationFunctionsSmallDataset))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLGEMMConvolutionLayerQuantizedMixedDataLayoutFixture< int8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(framework::dataset::make("Input", TensorShape(23U, 27U, 5U)), framework::dataset::make("Weights", TensorShape(3U, 3U, 5U, 2U))), framework::dataset::make("Bias", TensorShape(2U))), framework::dataset::make("Output", TensorShape(11U, 25U, 2U))), framework::dataset::make("PadStrideInfo", PadStrideInfo(2, 1, 0, 0))), framework::dataset::make("Dilation", Size2D(1, 1))), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), QuantizationData), QuantizedActivationFunctionsSmallDataset))
 
 combine (combine(combine(combine(combine(combine(datasets::SmallConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", { DataType::QASYMM8_SIGNED })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), QuantizationData), QuantizedActivationFunctionsSmallDataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMConvolutionLayerQuantizedPerChannelFixture< uint8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(datasets::SmallConvolutionLayerDataset(), framework::dataset::make("ReshapeWeights", { true })), framework::dataset::make("DataType", { DataType::QASYMM8 })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), QuantizationData), QuantizedActivationFunctionsSmallDataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLGEMMGroupedConvolutionLayerFixture< float >, framework::DatasetMode::ALL, 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(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(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), }), 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), })), framework::dataset::make("Expected", { 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::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(3, 20), 1, DataType::F32), })), framework::dataset::make("BoxIndInfo",{ 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, 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})), 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::U8))))
 
 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 (RunAsymm, CLDeconvolutionLayerAsymmFixture3x3< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(data3x3_asymm, 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(data9x9_small_asymm, framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NHWC })), framework::dataset::make("AddBias", { false })))
 
 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(combine(data4x4, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, 10), QuantizationInfo(2.f/255.f, 5) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, 5), QuantizationInfo(4.f/255.f, 10) })), add_bias_dataset))
 
 combine (combine(combine(combine(combine(data3x3_precommit, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, 10), QuantizationInfo(2.f/255.f, 4) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, 10), QuantizationInfo(4.f/255.f, 5) })), add_bias_dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDeconvolutionLayerQuantizedFixture3x3< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(data3x3, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, 10), QuantizationInfo(2.f/255.f, 128) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, 128), QuantizationInfo(4.f/255.f, 128) })), add_bias_dataset))
 
 combine (combine(combine(combine(combine(data2x2_precommit, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, 128), QuantizationInfo(2.f/255.f, 128) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, 64), QuantizationInfo(4.f/255.f, 128) })), add_bias_dataset))
 
 combine (combine(combine(combine(combine(data1x1, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, 0), QuantizationInfo(2.f/255.f, 0) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, 0), QuantizationInfo(4.f/255.f, 0) })), add_bias_dataset))
 
 combine (combine(combine(combine(combine(data4x4, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, 10), QuantizationInfo(2.f/255.f, 5) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, 5), QuantizationInfo(4.f/255.f, 10) })), add_bias_dataset))
 
 combine (combine(combine(combine(combine(data3x3_precommit, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, 10), QuantizationInfo(2.f/255.f, 4) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, 10), QuantizationInfo(4.f/255.f, 5) })), add_bias_dataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDeconvolutionLayerQuantizedFixture3x3< int8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(data3x3, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, -10), QuantizationInfo(2.f/255.f, 127) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, 64), QuantizationInfo(4.f/255.f, -128) })), add_bias_dataset))
 
 combine (combine(combine(combine(combine(data2x2_precommit, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, 127), QuantizationInfo(2.f/255.f, -128) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, -10), QuantizationInfo(4.f/255.f, 64) })), add_bias_dataset))
 
 combine (combine(combine(combine(combine(data1x1, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), data_layouts_dataset), framework::dataset::make("InputQuantizationInfo", { QuantizationInfo(1.f/255.f, 0), QuantizationInfo(2.f/255.f, 0) })), framework::dataset::make("OutputQuantizationInfo", { QuantizationInfo(3.f/255.f, 0), QuantizationInfo(4.f/255.f, 0) })), add_bias_dataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDeconvolutionLayerQuantizedPerChannelFixture4x4< uint8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(data4x4, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), input_qinfo_dataset), output_qinfo_dataset), add_bias_dataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 FIXTURE_DATA_TEST_CASE (RunSmallSigned, CLDeconvolutionLayerQuantizedPerChannelFixture4x4< int8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(data4x4, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), data_layouts_dataset), input_signed_qinfo_dataset), output_signed_qinfo_dataset), add_bias_dataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 combine (combine(combine(combine(combine(combine(data3x3, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), input_qinfo_dataset), output_qinfo_dataset), add_bias_dataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 FIXTURE_DATA_TEST_CASE (RunSmallSigned, CLDeconvolutionLayerQuantizedPerChannelFixture3x3< int8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(data3x3, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), data_layouts_dataset), input_signed_qinfo_dataset), output_signed_qinfo_dataset), add_bias_dataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 combine (combine(combine(combine(combine(combine(data2x2_precommit, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), input_qinfo_dataset), output_qinfo_dataset), add_bias_dataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 FIXTURE_DATA_TEST_CASE (RunSmallSigned, CLDeconvolutionLayerQuantizedPerChannelFixture2x2< int8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(data2x2_precommit, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), data_layouts_dataset), input_signed_qinfo_dataset), output_signed_qinfo_dataset), add_bias_dataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 combine (combine(combine(combine(combine(combine(data1x1, framework::dataset::make("DataType", DataType::QASYMM8)), data_layouts_dataset), input_qinfo_dataset), output_qinfo_dataset), add_bias_dataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 FIXTURE_DATA_TEST_CASE (RunSmallSigned, CLDeconvolutionLayerQuantizedPerChannelFixture1x1< int8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(data1x1, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), data_layouts_dataset), input_signed_qinfo_dataset), output_signed_qinfo_dataset), add_bias_dataset), framework::dataset::make("WeightsDataType", { DataType::QSYMM8_PER_CHANNEL })))
 
 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",{ 0, 0, 0, 1, 1, 0, })), framework::dataset::make("Expected", { false, false, false, false, false, true})), input_info, output_info, policy, shift, expected)
 
 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 })), DepthConvertLayerZeroShiftDataset))
 
 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 })), DepthConvertLayerZeroShiftDataset))
 
 combine (combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toS16Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerZeroShiftDataset))
 
 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 })), DepthConvertLayerZeroShiftDataset))
 
 combine (combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toS32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerZeroShiftDataset))
 
 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 })), DepthConvertLayerZeroShiftDataset))
 
 combine (combine(combine(datasets::SmallShapes(), DepthConvertLayerU16toU8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerZeroShiftDataset))
 
 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 })), DepthConvertLayerZeroShiftDataset))
 
 combine (combine(combine(datasets::SmallShapes(), DepthConvertLayerU16toU32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerZeroShiftDataset))
 
 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 })), DepthConvertLayerZeroShiftDataset))
 
 combine (combine(combine(datasets::SmallShapes(), DepthConvertLayerS16toU8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerZeroShiftDataset))
 
 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 })), DepthConvertLayerZeroShiftDataset))
 
 combine (combine(combine(datasets::SmallShapes(), DepthConvertLayerS16toS32Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), DepthConvertLayerZeroShiftDataset))
 
 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 })), DepthConvertLayerZeroShiftDataset))
 
 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 (Validate, 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_NEW (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_NEW (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_NEW (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_NEW (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_NEW (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_NEW (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_NEW (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_NEW (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_NEW (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_NEW (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(datasets::SmallInPlaceDepthwiseConvolutionLayerDataset(), framework::dataset::make("DepthMultiplier", { 1 })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { 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_NEW (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_NEW (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_NEW (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_NEW (RunMixedDataLayout, CLDepthwiseConvolutionLayerMixedDataLayoutFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset3x3(), framework::dataset::make("DepthMultiplier", { 2 })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", DataLayout::NHWC)), framework::dataset::make("ActivationInfo", ActivationLayerInfo())))
 
 FIXTURE_DATA_TEST_CASE_NEW (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_NEW (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_NEW (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_NEW (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_NEW (RunLargeKernelSize, CLDepthwiseConvolutionLayerFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::LargeKernelSizeDepthwiseConvolutionLayerNHWCDataset(), framework::dataset::make("DepthMultiplier", { 1 })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE_NEW (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_NEW (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))
 
 combine (combine(combine(combine(datasets::SmallInPlaceDepthwiseConvolutionLayerDataset(), framework::dataset::make("DepthMultiplier", { 1 })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE_NEW (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.5f, 128), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(1.f, 128) })), framework::dataset::make("DataLayout", { DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE_NEW (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), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.7f, 2) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE_NEW (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), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.8, 1) })), framework::dataset::make("DataLayout", { DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE_NEW (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), QuantizationInfo(1.3f, 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), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE_NEW (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), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE_NEW (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), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunMixedDataLayout, CLDepthwiseConvolutionLayerQuantizedMixedDataLayoutFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset3x3(), framework::dataset::make("DepthMultiplier", { 2 })), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.5f, 10), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), framework::dataset::make("ActivationInfo", ActivationLayerInfo())))
 
 FIXTURE_DATA_TEST_CASE_NEW (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), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 10) })), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.3f, 10), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 4) })), framework::dataset::make("DataLayout", { DataLayout::NCHW })), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunMixedDataLayout, CLDepthwiseConvolutionLayerQuantizedMixedDataLayoutFixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset(), framework::dataset::make("DepthMultiplier", { 2 })), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.3f, 10), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.5f, 4) })), framework::dataset::make("DataLayout", { DataLayout::NCHW })), framework::dataset::make("ActivationInfo", ActivationLayerInfo())))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunSmall, CLDepthwiseConvolutionLayerQuantizedFixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("SrcQuantizationInfo", { QuantizationInfo(0.5f, 10), QuantizationInfo(2.2f, 10) })), framework::dataset::make("DstQuantizationInfo", { QuantizationInfo(0.8, 1) })), framework::dataset::make("DataLayout", { DataLayout::NCHW })), ActivationFunctionsDataset))
 
 combine (combine(combine(combine(combine(combine(combine(datasets::SmallDepthwiseConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("SrcDataType", DataType::QASYMM8)), framework::dataset::make("WeightsDataType", DataType::QSYMM8_PER_CHANNEL)), 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_NEW (RunLarge, CLDepthwiseConvolutionLayerQuantizedPerChannelFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset(), large_depth_multipliers), framework::dataset::make("SrcDataType", DataType::QASYMM8)), framework::dataset::make("WeightsDataType", DataType::QSYMM8_PER_CHANNEL)), 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_NEW (RunSmall, CLDepthwiseConvolutionLayerQuantizedPerChannelFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset(), depth_multipliers), framework::dataset::make("SrcDataType", DataType::QASYMM8)), framework::dataset::make("WeightsDataType", DataType::QSYMM8_PER_CHANNEL)), 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_NEW (RunLarge, CLDepthwiseConvolutionLayerQuantizedPerChannelFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset(), large_depth_multipliers), framework::dataset::make("SrcDataType", DataType::QASYMM8)), framework::dataset::make("WeightsDataType", DataType::QSYMM8_PER_CHANNEL)), 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(combine(datasets::SmallDepthwiseConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("SrcDataType", DataType::QASYMM8)), framework::dataset::make("WeightsDataType", DataType::QSYMM8_PER_CHANNEL)), 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_NEW (RunLarge, CLDepthwiseConvolutionLayerQuantizedPerChannelFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(datasets::LargeDepthwiseConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("SrcDataType", DataType::QASYMM8)), framework::dataset::make("WeightsDataType", DataType::QSYMM8_PER_CHANNEL)), 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_NEW (RunSmall, CLDepthwiseConvolutionLayerQuantizedPerChannelFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(combine(datasets::SmallDepthwiseDilatedConvolutionLayerDataset3x3(), depth_multipliers), framework::dataset::make("SrcDataType", DataType::QASYMM8)), framework::dataset::make("WeightsDataType", DataType::QSYMM8_PER_CHANNEL)), 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_NEW (RunLarge, CLDepthwiseConvolutionLayerQuantizedPerChannelFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(datasets::LargeDepthwiseDilatedConvolutionLayerDataset3x3(), large_depth_multipliers), framework::dataset::make("SrcDataType", DataType::QASYMM8)), framework::dataset::make("WeightsDataType", DataType::QSYMM8_PER_CHANNEL)), 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_NEW (RunSmall, CLDepthwiseConvolutionLayerNativeFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_precommit, height_values_precommit), channel_values_precommit), batch_values_precommit), kernel_sz_values_precommit), framework::dataset::make("depth_multiplier", 1)), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F32)), data_layout_values), act_values), n0_values_precommit), framework::dataset::make("ExportToCLImage", false)))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunLarge, CLDepthwiseConvolutionLayerNativeFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_nightly, height_values_nightly), channel_values_nightly), batch_values_nightly), kernel_sz_values_nightly), framework::dataset::make("depth_multiplier", 1)), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F32)), data_layout_values), act_values), n0_values_nightly), framework::dataset::make("ExportToCLImage", false)))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunSmall, CLDepthwiseConvolutionLayerNativeFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_precommit, height_values_precommit), channel_values_export_to_cl_image_precommit), batch_values_precommit), kernel_sz_values_precommit), framework::dataset::make("depth_multiplier", 1)), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F32)), data_layout_values), act_values), n0_values_export_to_cl_image_precommit), framework::dataset::make("ExportToCLImage", true)))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunLarge, CLDepthwiseConvolutionLayerNativeFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_nightly, height_values_nightly), channel_values_export_to_cl_image_nightly), batch_values_nightly), kernel_sz_values_nightly), framework::dataset::make("depth_multiplier", 1)), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F32)), data_layout_values), act_values), n0_values_export_to_cl_image_nightly), framework::dataset::make("ExportToCLImage", true)))
 
 combine (combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_precommit, height_values_precommit), channel_values_precommit), batch_values_precommit), kernel_sz_values_precommit), framework::dataset::make("depth_multiplier", 1)), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F16)), data_layout_values), act_values), n0_values_precommit), framework::dataset::make("ExportToCLImage", false)))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunLarge, CLDepthwiseConvolutionLayerNativeFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_nightly, height_values_nightly), channel_values_nightly), batch_values_nightly), kernel_sz_values_nightly), framework::dataset::make("depth_multiplier", 1)), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F16)), data_layout_values), act_values), n0_values_nightly), framework::dataset::make("ExportToCLImage", false)))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunSmall, CLDepthwiseConvolutionLayerNativeFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_precommit, height_values_precommit), channel_values_export_to_cl_image_precommit), batch_values_precommit), kernel_sz_values_precommit), framework::dataset::make("depth_multiplier", 1)), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F16)), data_layout_values), act_values), n0_values_export_to_cl_image_precommit), framework::dataset::make("ExportToCLImage", true)))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunLarge, CLDepthwiseConvolutionLayerNativeFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_nightly, height_values_nightly), channel_values_export_to_cl_image_nightly), batch_values_nightly), kernel_sz_values_nightly), framework::dataset::make("depth_multiplier", 1)), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F16)), data_layout_values), act_values), n0_values_export_to_cl_image_nightly), framework::dataset::make("ExportToCLImage", true)))
 
 combine (combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_precommit, height_values_precommit), channel_values_precommit), batch_values_precommit), kernel_sz_values_precommit), depth_multiplier_values), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F32)), data_layout_values), act_values), framework::dataset::make("N0", 1)), framework::dataset::make("ExportToCLImage", false)))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunLarge, CLDepthwiseConvolutionLayerNativeFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_nightly, height_values_nightly), channel_values_nightly), batch_values_nightly), kernel_sz_values_nightly), depth_multiplier_values), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F32)), data_layout_values), act_values), framework::dataset::make("N0", 1)), framework::dataset::make("ExportToCLImage", false)))
 
 combine (combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_precommit, height_values_precommit), channel_values_precommit), batch_values_precommit), kernel_sz_values_precommit), depth_multiplier_values), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F16)), data_layout_values), act_values), framework::dataset::make("N0", 1)), framework::dataset::make("ExportToCLImage", false)))
 
 FIXTURE_DATA_TEST_CASE_NEW (RunLarge, CLDepthwiseConvolutionLayerNativeFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_nightly, height_values_nightly), channel_values_nightly), batch_values_nightly), kernel_sz_values_nightly), depth_multiplier_values), dilation_values), stride_values), padding_valid_values), framework::dataset::make("DataType", DataType::F16)), data_layout_values), act_values), framework::dataset::make("N0", 1)), framework::dataset::make("ExportToCLImage", false)))
 
 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)
 
 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)
 
 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() })))
 
 TEST_CASE (NoBias, framework::DatasetMode::PRECOMMIT)
 Check whether the configuration of a Direct Convolution layer with no bias leads to a successful execution. More...
 
 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(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(27U, 13U, 23U), TensorShape(19U, 5U, 16U, 4U), TensorShape(13U, 5U, 17U, 2U), TensorShape(32U, 37U, 13U) }), framework::dataset::make("StrideX", { 1, 3, 1, 1 })), framework::dataset::make("StrideY", { 1, 3, 2, 1 })), framework::dataset::make("PadX", { 1, 3, 0, 4 })), framework::dataset::make("PadY", { 1, 3, 0, 4 })), framework::dataset::make("KernelSize", { 3, 8, 1, 9 })), framework::dataset::make("NumKernels", { 17, 3, 1, 19 })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDirectConvolutionLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(800U, 800U, 3U) }), framework::dataset::make("StrideX", { 1 })), framework::dataset::make("StrideY", { 1 })), framework::dataset::make("PadX", { 1 })), framework::dataset::make("PadY", { 1 })), framework::dataset::make("KernelSize", { 9 })), framework::dataset::make("NumKernels", { 3 })), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::IDENTITY))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 combine (combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(27U, 13U, 23U), TensorShape(19U, 5U, 16U, 4U), TensorShape(13U, 5U, 17U, 2U), TensorShape(32U, 37U, 13U) }), framework::dataset::make("StrideX", { 1, 3, 1, 1 })), framework::dataset::make("StrideY", { 1, 3, 2, 1 })), framework::dataset::make("PadX", { 1, 3, 0, 4 })), framework::dataset::make("PadY", { 1, 3, 0, 4 })), framework::dataset::make("KernelSize", { 3, 8, 1, 9 })), framework::dataset::make("NumKernels", { 17, 3, 1, 19 })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLDirectConvolutionLayerMixedDataLayoutFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(27U, 13U, 23U), TensorShape(19U, 5U, 16U, 4U), TensorShape(13U, 5U, 17U, 2U), TensorShape(32U, 37U, 13U) }), framework::dataset::make("StrideX", { 1 })), framework::dataset::make("StrideY", { 2 })), framework::dataset::make("PadX", { 1 })), framework::dataset::make("PadY", { 3 })), framework::dataset::make("KernelSize", { 3 })), framework::dataset::make("NumKernels", { 3 })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDirectConvolutionLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(800U, 800U, 3U) }), framework::dataset::make("StrideX", { 1 })), framework::dataset::make("StrideY", { 1 })), framework::dataset::make("PadX", { 1 })), framework::dataset::make("PadY", { 1 })), framework::dataset::make("KernelSize", { 9 })), framework::dataset::make("NumKernels", { 3 })), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::IDENTITY))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 combine (combine(combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(27U, 13U, 23U), TensorShape(19U, 5U, 16U, 4U), TensorShape(13U, 5U, 17U, 2U), TensorShape(32U, 37U, 13U) }), framework::dataset::make("StrideX", { 1, 3, 1, 1 })), framework::dataset::make("StrideY", { 1, 3, 2, 1 })), framework::dataset::make("PadX", { 1, 3, 0, 4 })), framework::dataset::make("PadY", { 1, 3, 0, 4 })), framework::dataset::make("KernelSize", { 3, 8, 1, 9 })), framework::dataset::make("NumKernels", { 7, 3, 1, 3 })), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", QuantizationInfo(1.1f/255, 10))), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLDirectConvolutionLayerQuantizedMixedDataLayoutFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(27U, 13U, 23U), TensorShape(19U, 5U, 16U, 4U), TensorShape(13U, 5U, 17U, 2U), TensorShape(32U, 37U, 13U) }), framework::dataset::make("StrideX", { 1 })), framework::dataset::make("StrideY", { 2 })), framework::dataset::make("PadX", { 1 })), framework::dataset::make("PadY", { 1 })), framework::dataset::make("KernelSize", { 3 })), framework::dataset::make("NumKernels", { 3 })), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", QuantizationInfo(1.1f/255, 10))), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDirectConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(800U, 800U, 3U) }), framework::dataset::make("StrideX", { 1 })), framework::dataset::make("StrideY", { 1 })), framework::dataset::make("PadX", { 1 })), framework::dataset::make("PadY", { 1 })), framework::dataset::make("KernelSize", { 9 })), framework::dataset::make("NumKernels", { 3 })), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", QuantizationInfo(2.f/255, 10))), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 combine (combine(combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(27U, 13U, 23U), TensorShape(19U, 5U, 16U, 4U), TensorShape(13U, 5U, 17U, 2U), TensorShape(32U, 37U, 13U) }), framework::dataset::make("StrideX", { 1, 3, 1, 1 })), framework::dataset::make("StrideY", { 1, 3, 2, 1 })), framework::dataset::make("PadX", { 1, 3, 0, 4 })), framework::dataset::make("PadY", { 1, 3, 0, 4 })), framework::dataset::make("KernelSize", { 3, 8, 1, 9 })), framework::dataset::make("NumKernels", { 7, 3, 1, 3 })), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("QuantizationInfo", QuantizationInfo(2.f/255, 10))), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLDirectConvolutionLayerQuantizedMixedDataLayoutFixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(27U, 13U, 23U), TensorShape(19U, 5U, 16U, 4U), TensorShape(13U, 5U, 17U, 2U), TensorShape(32U, 37U, 13U) }), framework::dataset::make("StrideX", { 1 })), framework::dataset::make("StrideY", { 1 })), framework::dataset::make("PadX", { 1 })), framework::dataset::make("PadY", { 1 })), framework::dataset::make("KernelSize", { 3 })), framework::dataset::make("NumKernels", { 3 })), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("QuantizationInfo", QuantizationInfo(2.f/255, 10))), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDirectConvolutionLayerQuantizedFixture< int8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(zip(zip(zip(zip(zip(zip(framework::dataset::make("InputShape", { TensorShape(800U, 800U, 3U) }), framework::dataset::make("StrideX", { 1 })), framework::dataset::make("StrideY", { 1 })), framework::dataset::make("PadX", { 1 })), framework::dataset::make("PadY", { 1 })), framework::dataset::make("KernelSize", { 9 })), framework::dataset::make("NumKernels", { 3 })), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("QuantizationInfo", QuantizationInfo(2.f/255, 10))), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))), framework::dataset::make("DataLayout", DataLayout::NHWC)))
 
 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)))
 
 combine (combine(combine(data_precommit, framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLDirectConvolutionLayerMixedDataLayoutFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(data_precommit, framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 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 })))
 
 combine (combine(datasets::DirectConvolutionLayerDataset(), framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLDirectConvolutionLayerQuantizedMixedDataLayoutFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(data_precommit, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLDirectConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(data_precommit, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 10), QuantizationInfo(1.1f, 10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall9x9, CLDirectConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(data_precommit_9x9, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(3.f/255, 10), QuantizationInfo(1.1f, 10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLDirectConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(data_nightly, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 10), QuantizationInfo(1.1f, 10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 FIXTURE_DATA_TEST_CASE (RunLarge9x9, CLDirectConvolutionLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(data_nightly_9x9, framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(3.f/255, 10), QuantizationInfo(1.1f, 10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 combine (combine(combine(combine(datasets::DirectConvolutionLayerDataset(), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 127), QuantizationInfo(1.1f, 10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 combine (combine(combine(combine(data_precommit, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 10), QuantizationInfo(1.1f, -10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLDirectConvolutionLayerQuantizedMixedDataLayoutFixture< int8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(data_precommit, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.1f, -10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })))
 
 FIXTURE_DATA_TEST_CASE (RunSmall9x9, CLDirectConvolutionLayerQuantizedFixture< int8_t >, framework::DatasetMode::ALL, combine(combine(combine(combine(data_precommit_9x9, framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 10), QuantizationInfo(1.1f, 10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 FIXTURE_DATA_TEST_CASE (RunCustomDataset, CLDirectConvolutionValidationWithTensorShapesQuantizedFixture< int8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::DirectConvolutionLayerDataset(), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f/255, 127), QuantizationInfo(1.1f, 10) })), QuantizedActivationFunctionsDataset), framework::dataset::make("DataLayout", { DataLayout::NCHW })))
 
 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(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::S16), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("OutputInfo",{TensorInfo(TensorShape(32U, 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, false, false})), input1_info, input2_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ElementwiseMaxU8Dataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxFixture< int16_t >, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), ElementwiseMaxS16Dataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxQuantizedFixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseMaxQASYMM8SignedDataset), 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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxQuantizedFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), ElementwiseMaxFP16Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLElementwiseMaxFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ElementwiseMaxFP16Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMaxFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), ElementwiseMaxFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLElementwiseMaxFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ElementwiseMaxFP32Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwiseMaxBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapesBroadcast(), ElementwiseMaxFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivationBroadcast, CLElementwiseMaxBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapesBroadcast(), ElementwiseMaxFP32Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 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(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::S16), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 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, false, false})), input1_info, input2_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ElementwiseMinU8Dataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinFixture< int16_t >, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), ElementwiseMinS16Dataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinQuantizedFixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseMinQASYMM8SignedDataset), 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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinQuantizedFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), ElementwiseMinFP16Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLElementwiseMinFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ElementwiseMinFP16Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseMinFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), ElementwiseMinFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLElementwiseMinFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ElementwiseMinFP32Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwiseMinBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapesBroadcast(), ElementwiseMinFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivationBroadcast, CLElementwiseMinBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapesBroadcast(), ElementwiseMinFP32Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 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(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(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(32U, 13U, 2U), 1, DataType::U8), TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, true, false, false})), input1_info, input2_info, output_info, expected)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwisePowerFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), ElementwisePowerFP16Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLElementwisePowerFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ElementwisePowerFP16Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwisePowerBroadcastFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapesBroadcast(), ElementwisePowerFP16Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivationBroadcast, CLElementwisePowerBroadcastFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapesBroadcast(), ElementwisePowerFP16Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 combine (combine(combine(datasets::SmallShapes(), ElementwisePowerFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLElementwisePowerFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ElementwisePowerFP32Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwisePowerBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapesBroadcast(), ElementwisePowerFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivationBroadcast, CLElementwisePowerBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapesBroadcast(), ElementwisePowerFP32Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ElementwiseSquaredDiffU8Dataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffFixture< int16_t >, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), ElementwiseSquaredDiffS16Dataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffQuantizedFixture< int16_t >, framework::DatasetMode::PRECOMMIT, combine(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) })), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), ElementwiseSquaredDiffFP16Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLElementwiseSquaredDiffFloatFixture< half >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ElementwiseSquaredDiffFP16Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLElementwiseSquaredDiffFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), ElementwiseSquaredDiffFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivation, CLElementwiseSquaredDiffFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapes(), ElementwiseSquaredDiffFP32Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunSmallBroadcast, CLElementwiseSquaredDiffBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapesBroadcast(), ElementwiseSquaredDiffFP32Dataset), EmptyActivationFunctionsDataset), OutOfPlaceDataSet))
 
 FIXTURE_DATA_TEST_CASE (RunWithActivationBroadcast, CLElementwiseSquaredDiffBroadcastFloatFixture< float >, framework::DatasetMode::ALL, combine(combine(combine(datasets::TinyShapesBroadcast(), ElementwiseSquaredDiffFP32Dataset), ActivationFunctionsDataset), OutOfPlaceDataSet))
 
 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 (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_1d, framework::dataset::make("DataType", DataType::F16)))
 
 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 }))
 
 ARM_COMPUTE_EXPECT (bool(s)==expected, framework::LogLevel::ERRORS)
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFFT2DFixture< float >, framework::DatasetMode::ALL, combine(shapes_2d, framework::dataset::make("DataType", DataType::F32)))
 
 combine (shapes_2d, framework::dataset::make("DataType", DataType::F16)))
 
 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))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLFFTConvolutionLayerMixedDataLayoutFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallFFTConvolutionLayerDataset(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsSmallDataset))
 
 combine (combine(combine(datasets::SmallFFTConvolutionLayerDataset(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), ActivationFunctionsSmallDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFillFixture< uint8_t >, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U8)))
 
 combine (datasets::SmallShapes(), framework::dataset::make("DataType", DataType::S8)))
 
 combine (datasets::SmallShapes(), framework::dataset::make("DataType", DataType::QASYMM8)))
 
 combine (datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U16)))
 
 combine (datasets::SmallShapes(), framework::dataset::make("DataType", DataType::S16)))
 
 combine (datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F16)))
 
 combine (datasets::SmallShapes(), framework::dataset::make("DataType", DataType::U32)))
 
 combine (datasets::SmallShapes(), framework::dataset::make("DataType", DataType::S32)))
 
 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(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(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, 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 (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(combine(datasets::SmallFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::F16)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFullyConnectedLayerFixture< half >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::F16)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFullyConnectedLayerFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLFullyConnectedLayerMixedDataLayoutFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(framework::dataset::make("Input", TensorShape(9U, 5U, 7U)), framework::dataset::make("Weights", TensorShape(315U, 271U))), framework::dataset::make("Biases", TensorShape(271U))), framework::dataset::make("Output", TensorShape(271U))), FullyConnectedParameters), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))))
 
 FIXTURE_DATA_TEST_CASE (RunDynamicWeights, CLFullyConnectedLayerDynamicWeightsFixture< float >, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallFullyConnectedLayerDataset(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFullyConnectedLayerFixture< float >, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::F32)), ActivationFunctionsDataset))
 
 FIXTURE_DATA_TEST_CASE (RunSmall, CLFullyConnectedLayerQuantizedFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::QASYMM8)), QuantizationData), ActivationFunctionsQuantizedDataset))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLFullyConnectedLayerQuantizedMixedDataLayoutFixture< uint8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(combine(framework::dataset::make("Input", TensorShape(9U, 5U, 7U)), framework::dataset::make("Weights", TensorShape(315U, 271U))), framework::dataset::make("Biases", TensorShape(271U))), framework::dataset::make("Output", TensorShape(271U))), FullyConnectedParameters), framework::dataset::make("DataType", DataType::QASYMM8)), QuantizationData), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))))
 
 FIXTURE_DATA_TEST_CASE (RunLarge, CLFullyConnectedLayerQuantizedFixture< uint8_t >, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::QASYMM8)), QuantizationData), ActivationFunctionsQuantizedDataset))
 
 combine (combine(combine(combine(datasets::SmallFullyConnectedLayerDataset(), FullyConnectedParameters), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), QuantizationData), ActivationFunctionsQuantizedDataset))
 
 FIXTURE_DATA_TEST_CASE (RunMixedDataLayout, CLFullyConnectedLayerQuantizedMixedDataLayoutFixture< int8_t >, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(combine(framework::dataset::make("Input", TensorShape(9U, 5U, 7U)), framework::dataset::make("Weights", TensorShape(315U, 271U))), framework::dataset::make("Biases", TensorShape(271U))), framework::dataset::make("Output", TensorShape(271U))), FullyConnectedParameters), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)), QuantizationData), framework::dataset::make("ActivationInfo", ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU))))
 
 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)
 
 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, 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,