//
// Copyright © 2017-2024 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include <backendsCommon/test/EndToEndTestImpl.hpp>

#include <backendsCommon/test/ActivationEndToEndTestImpl.hpp>
#include <backendsCommon/test/AdditionEndToEndTestImpl.hpp>
#include <backendsCommon/test/ArgMinMaxEndToEndTestImpl.hpp>
#include <backendsCommon/test/BatchMatMulEndToEndTestImpl.hpp>
#include <backendsCommon/test/ComparisonEndToEndTestImpl.hpp>
#include <backendsCommon/test/ConcatEndToEndTestImpl.hpp>
#include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp>
#include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
#include <backendsCommon/test/ElementwiseBinaryEndToEndTestImpl.hpp>
#include <backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp>
#include <backendsCommon/test/FillEndToEndTestImpl.hpp>
#include <backendsCommon/test/InstanceNormalizationEndToEndTestImpl.hpp>
#include "backendsCommon/test/Pooling2dEndToEndTestImpl.hpp"
#include <backendsCommon/test/PreluEndToEndTestImpl.hpp>
#include <backendsCommon/test/QLstmEndToEndTestImpl.hpp>
#include <backendsCommon/test/QuantizedLstmEndToEndTestImpl.hpp>
#include <backendsCommon/test/ReduceEndToEndTestImpl.hpp>
#include <backendsCommon/test/ReshapeEndToEndTestImpl.hpp>
#include <backendsCommon/test/ResizeEndToEndTestImpl.hpp>
#include <backendsCommon/test/ReverseV2EndToEndTestImpl.hpp>
#include <backendsCommon/test/SliceEndToEndTestImpl.hpp>
#include <backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp>
#include <backendsCommon/test/SplitterEndToEndTestImpl.hpp>
#include <backendsCommon/test/SubgraphUtilsTest.hpp>
#include <backendsCommon/test/TileEndToEndTestImpl.hpp>
#include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp>
#include <backendsCommon/test/TransposeEndToEndTestImpl.hpp>

#include <doctest/doctest.h>

TEST_SUITE("ClEndToEnd")
{
std::vector<armnn::BackendId> clDefaultBackends = {armnn::Compute::GpuAcc};

// Activations
// Linear
TEST_CASE("ClLinearEndToEndTestFloat32")
{
    ActivationEndToEndTest<armnn::DataType::Float32>(clDefaultBackends, ActivationFunction::Linear);
}

TEST_CASE("ClLinearEndToEndTestFloat16")
{
    ActivationEndToEndTest<armnn::DataType::Float16>(clDefaultBackends, ActivationFunction::Linear);
}

// Sigmoid
TEST_CASE("ClSigmoidEndToEndTestFloat32")
{
    ActivationEndToEndTest<armnn::DataType::Float32>(clDefaultBackends, ActivationFunction::Sigmoid);
}

// ReLu
TEST_CASE("ClReLuEndToEndTestFloat32")
{
    ActivationEndToEndTest<armnn::DataType::Float32>(clDefaultBackends, ActivationFunction::ReLu);
}

TEST_CASE("ClReLuEndToEndTestFloat16")
{
    ActivationEndToEndTest<armnn::DataType::Float16>(clDefaultBackends, ActivationFunction::ReLu);
}

// BoundedReLu
TEST_CASE("ClBoundedReLuEndToEndTestFloat32")
{
    ActivationEndToEndTest<armnn::DataType::Float32>(clDefaultBackends, ActivationFunction::BoundedReLu);
}

TEST_CASE("ClBoundedReLuEndToEndTestFloat16")
{
    ActivationEndToEndTest<armnn::DataType::Float16>(clDefaultBackends, ActivationFunction::BoundedReLu);
}

// SoftReLu
TEST_CASE("ClSoftReLuEndToEndTestFloat32")
{
    ActivationEndToEndTest<armnn::DataType::Float32>(clDefaultBackends, ActivationFunction::SoftReLu);
}

// LeakyRelu
TEST_CASE("ClLeakyReluActivationFloat32")
{
    ActivationEndToEndTest<DataType::Float32>(clDefaultBackends, ActivationFunction::LeakyReLu, 1.f, 0, 0.01f);
}

TEST_CASE("ClLeakyReluActivationFloat16")
{
    ActivationEndToEndTest<DataType::Float16>(clDefaultBackends, ActivationFunction::LeakyReLu, 0.3f, 5, 0.01f);
}

// Elu
TEST_CASE("ClEluEndToEndTestFloat32")
{
    ActivationEndToEndTest<DataType::Float32>(clDefaultBackends, ActivationFunction::Elu);
}

TEST_CASE("ClEluEndToEndTestFloat16")
{
    ActivationEndToEndTest<DataType::Float16>(clDefaultBackends, ActivationFunction::Elu);
}

// HardSwish
TEST_CASE("ClHardSwishEndToEndTestFloat32")
{
    ActivationEndToEndTest<DataType::Float32>(clDefaultBackends, ActivationFunction::HardSwish);
}

TEST_CASE("ClHardSwishEndToEndTestFloat16")
{
    ActivationEndToEndTest<DataType::Float16>(clDefaultBackends, ActivationFunction::HardSwish);
}

// TanH
TEST_CASE("ClTanHEndToEndTestFloat32")
{
    ActivationEndToEndTest<DataType::Float32>(clDefaultBackends, ActivationFunction::TanH, 1.f, 0, 2, 3);
}

TEST_CASE("ClTanHEndToEndTestFloat16")
{
    ActivationEndToEndTest<DataType::Float16>(clDefaultBackends, ActivationFunction::TanH, 1.f, 0, 2, 3);
}

// ElementwiseUnary
// Abs
TEST_CASE("ClAbsEndToEndTestFloat32")
{
    ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, UnaryOperation::Abs);
}
// Rsqrt
TEST_CASE("ClRsqrtEndToEndTestFloat32")
{
    ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, UnaryOperation::Rsqrt);
}

// ElementwiseBinary
// Addition
TEST_CASE("ClAdditionEndToEndFloat32Test")
{
    AdditionEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}
TEST_CASE("ClAdditionEndToEndUint8Test")
{
    AdditionEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClAdditionEndToEndFloat32Simple3DTest")
{
    ElementwiseBinarySimple3DEndToEnd<armnn::DataType::Float32>(clDefaultBackends, BinaryOperation::Add);
}
TEST_CASE("ClAdditionEndToEndFloat16Simple3DTest")
{
    ElementwiseBinarySimple3DEndToEnd<armnn::DataType::Float16>(clDefaultBackends, BinaryOperation::Add);
}

// Div
TEST_CASE("ClDivEndToEndTestFloat32")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, BinaryOperation::Div);
}

// Mul
TEST_CASE("ClMulEndToEndTestFloat32")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, BinaryOperation::Mul);
}
TEST_CASE("ClMulEndToEndTestUint8")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, BinaryOperation::Mul);
}

// Sub
TEST_CASE("ClSubtractionEndToEndFloat32Simple3DTest")
{
    ElementwiseBinarySimple3DEndToEnd<armnn::DataType::Float32>(clDefaultBackends, BinaryOperation::Sub);
}
TEST_CASE("ClSubtractionEndToEndFloat16Simple3DTest")
{
    ElementwiseBinarySimple3DEndToEnd<armnn::DataType::Float16>(clDefaultBackends, BinaryOperation::Sub);
}

// Max
TEST_CASE("ClMaximumEndToEndTestFloat32")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, BinaryOperation::Maximum);
}
TEST_CASE("ClMaximumEndToEndTestUint8")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, BinaryOperation::Maximum);
}

// Min
TEST_CASE("ClMinimumEndToEndTestFloat32")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, BinaryOperation::Minimum);
}
TEST_CASE("ClMinimumEndToEndTestUint8")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, BinaryOperation::Minimum);
}

// Power
TEST_CASE("ClPowerEndToEndTestFloat32")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, BinaryOperation::Power);
}

// SqDiff
TEST_CASE("ClSquaredDifferenceEndToEndTestFloat32")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, BinaryOperation::SqDiff);
}
TEST_CASE("ClSquaredDifferenceEndToEndTestUint8")
{
    ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, BinaryOperation::SqDiff);
}

// Batch Mat Mul
TEST_CASE("ClBatchMatMulEndToEndFloat32Test")
{
    BatchMatMulEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClBatchMatMulEndToEndInt8Test")
{
    BatchMatMulEndToEnd<armnn::DataType::QAsymmS8>(clDefaultBackends);
}

// Constant
TEST_CASE("ConstantUsage_Cl_Float32")
{
    ConstantUsageFloat32Test(clDefaultBackends);
}

TEST_CASE("ClConcatEndToEndDim0Test")
{
    ConcatDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClConcatEndToEndDim0Uint8Test")
{
    ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClConcatEndToEndDim1Test")
{
    ConcatDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClConcatEndToEndDim1Uint8Test")
{
    ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClConcatEndToEndDim3Test")
{
    ConcatDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClConcatEndToEndDim3Uint8Test")
{
    ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

// DepthToSpace
TEST_CASE("DephtToSpaceEndToEndNchwFloat32")
{
    DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NCHW);
}

TEST_CASE("DephtToSpaceEndToEndNchwFloat16")
{
    DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NCHW);
}

TEST_CASE("DephtToSpaceEndToEndNchwUint8")
{
    DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NCHW);
}

TEST_CASE("DephtToSpaceEndToEndNchwInt16")
{
    DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NCHW);
}

TEST_CASE("DephtToSpaceEndToEndNhwcFloat32")
{
    DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NHWC);
}

TEST_CASE("DephtToSpaceEndToEndNhwcFloat16")
{
    DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NHWC);
}

TEST_CASE("DephtToSpaceEndToEndNhwcUint8")
{
    DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NHWC);
}

TEST_CASE("DephtToSpaceEndToEndNhwcInt16")
{
    DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NHWC);
}

// Dequantize
TEST_CASE("DequantizeEndToEndSimpleTest")
{
    DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("DequantizeEndToEndOffsetTest")
{
    DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

// Slice
TEST_CASE("ClSliceEndtoEndTestFloat32")
{
    SliceEndToEnd<DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSliceEndtoEndTestInt32")
{
    SliceEndToEnd<DataType::Signed32>(clDefaultBackends);
}

TEST_CASE("ClSliceEndtoEndTestFloat16")
{
    SliceEndToEndFloat16<DataType::Float16>(clDefaultBackends);
}

TEST_CASE("ClStridedSliceInvalidSliceEndToEndTest")
{
    StridedSliceInvalidSliceEndToEndTest(clDefaultBackends);
}

TEST_CASE("ClGreaterSimpleEndToEndTest")
{
    const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
                                                0, 0, 0, 0,  0, 0, 0, 0 });

    ComparisonSimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
                                                       ComparisonOperation::Greater,
                                                       expectedOutput);
}

TEST_CASE("ClGreaterSimpleEndToEndUint8Test")
{
    const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
                                                0, 0, 0, 0,  0, 0, 0, 0 });

    ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends,
                                                        ComparisonOperation::Greater,
                                                        expectedOutput);
}

TEST_CASE("ClGreaterBroadcastEndToEndTest")
{
    const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
                                                1, 1, 1, 1, 1, 1 });

    ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
                                                          ComparisonOperation::Greater,
                                                          expectedOutput);
}

TEST_CASE("ClGreaterBroadcastEndToEndUint8Test")
{
    const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
                                                1, 1, 1, 1, 1, 1 });

    ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends,
                                                           ComparisonOperation::Greater,
                                                           expectedOutput);
}

// InstanceNormalization
TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest1")
{
    InstanceNormalizationNhwcEndToEndTest1(clDefaultBackends);
}

TEST_CASE("ClInstanceNormalizationNchwEndToEndTest1")
{
    InstanceNormalizationNchwEndToEndTest1(clDefaultBackends);
}

TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest2")
{
    InstanceNormalizationNhwcEndToEndTest2(clDefaultBackends);
}

TEST_CASE("ClInstanceNormalizationNchwEndToEndTest2")
{
    InstanceNormalizationNchwEndToEndTest2(clDefaultBackends);
}

// Pooling 2D
// Average Pool 2D
TEST_CASE("ClAvgPool2DEndtoEndTestFloat32")
{
    AvgPool2dEndToEnd<DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClAvgPool2DEndtoEndTestFloat16")
{
    AvgPool2dEndToEndFloat16<DataType::Float16>(clDefaultBackends);
}

TEST_CASE("ClAvgPool2DIgnoreValueEndtoEndTestFloat32")
{
    AvgPool2dEndToEnd<DataType::Float32>(clDefaultBackends, PaddingMethod::IgnoreValue);
}

// Max Pool 2D
TEST_CASE("ClMaxPool2DEndtoEndTestFloat32")
{
    MaxPool2dEndToEnd<DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClMaxPool2DEndtoEndTestFloat16")
{
    MaxPool2dEndToEndFloat16<DataType::Float16>(clDefaultBackends);
}

TEST_CASE("ClMaxPool2DIgnoreValueEndtoEndTestFloat32")
{
    MaxPool2dEndToEnd<DataType::Float32>(clDefaultBackends, PaddingMethod::IgnoreValue);
}

TEST_CASE("ClMaxPool2DTwoLayerEndtoEndTestFloat32")
{
    MaxPool2dTwoLayerEndToEnd<DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClMaxPool2DThreeLayerEndtoEndTestFloat32")
{
    MaxPool2dThreeLayerEndToEnd<DataType::Float32>(clDefaultBackends);
}

// Fill
TEST_CASE("ClFillEndToEndTest")
{
    FillEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClFillEndToEndTestFloat16")
{
    FillEndToEnd<armnn::DataType::Float16>(clDefaultBackends);
}

TEST_CASE("ClFillEndToEndTestInt32")
{
    FillEndToEnd<armnn::DataType::Signed32>(clDefaultBackends);
}

// Prelu
TEST_CASE("ClPreluEndToEndFloat32Test")
{
    PreluEndToEndNegativeTest<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClPreluEndToEndTestUint8")
{
    PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

// Reduce
TEST_CASE("ClReduceEndToEndTest")
{
    ReduceEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClReduceEndToEndTestFloat16")
{
    ReduceEndToEnd<armnn::DataType::Float16>(clDefaultBackends);
}

// Reshape
TEST_CASE("ClReshapeEndToEndTest")
{
    ReshapeEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClReshapeEndToEndTestFloat16")
{
    ReshapeEndToEndFloat16<armnn::DataType::Float16>(clDefaultBackends);
}

TEST_CASE("ClReshapeEndToEndTestInt32")
{
    ReshapeEndToEnd<armnn::DataType::Signed32>(clDefaultBackends);
}

TEST_CASE("ClReshapeEndToEndTestInt16")
{
    ReshapeEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends);
}

TEST_CASE("ClReshapeEndToEndTestUInt8")
{
    ReshapeEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClReshapeEndToEndTestInt8")
{
    ReshapeEndToEnd<armnn::DataType::QAsymmS8>(clDefaultBackends);
}

// Resize Bilinear
TEST_CASE("ClResizeBilinearEndToEndFloatNchwTest")
{
    ResizeBilinearEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NCHW);
}

TEST_CASE("ClResizeBilinearEndToEndFloatNhwcTest")
{
    ResizeBilinearEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NHWC);
}

// Resize NearestNeighbor
TEST_CASE("ClResizeNearestNeighborEndToEndFloatNchwTest")
{
    ResizeNearestNeighborEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NCHW);
}

TEST_CASE("ClResizeNearestNeighborEndToEndFloatNhwcTest")
{
    ResizeNearestNeighborEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NHWC);
}

TEST_CASE("ClResizeNearestNeighborEndToEndFloatAlignCornersNhwcTest")
{
    ResizeNearestNeighborEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NHWC, true, false);
}

TEST_CASE("ClResizeNearestNeighborEndToEndFloatHalfPixelNhwcTest")
{
    ResizeNearestNeighborEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NHWC, false, true);
}

// ReverseV2
TEST_CASE("ClReverseV2EndToEndTest")
{
    ReverseV2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

// Space to depth
TEST_CASE("ClSpaceToDepthNhwcEndToEndTest1")
{
    SpaceToDepthNhwcEndToEndTest1(clDefaultBackends);
}

TEST_CASE("ClSpaceToDepthNchwEndToEndTest1")
{
    SpaceToDepthNchwEndToEndTest1(clDefaultBackends);
}

TEST_CASE("ClSpaceToDepthNhwcEndToEndTest2")
{
    SpaceToDepthNhwcEndToEndTest2(clDefaultBackends);
}

TEST_CASE("ClSpaceToDepthNchwEndToEndTest2")
{
    SpaceToDepthNchwEndToEndTest2(clDefaultBackends);
}

// Split
TEST_CASE("ClSplitter1dEndToEndTest")
{
    Splitter1dEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter1dEndToEndUint8Test")
{
    Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClSplitter2dDim0EndToEndTest")
{
    Splitter2dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter2dDim1EndToEndTest")
{
    Splitter2dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter2dDim0EndToEndUint8Test")
{
    Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClSplitter2dDim1EndToEndUint8Test")
{
    Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClSplitter3dDim0EndToEndTest")
{
    Splitter3dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter3dDim1EndToEndTest")
{
    Splitter3dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter3dDim2EndToEndTest")
{
    Splitter3dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter3dDim0EndToEndUint8Test")
{
    Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClSplitter3dDim1EndToEndUint8Test")
{
    Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClSplitter3dDim2EndToEndUint8Test")
{
    Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClSplitter4dDim0EndToEndTest")
{
    Splitter4dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter4dDim1EndToEndTest")
{
    Splitter4dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter4dDim2EndToEndTest")
{
    Splitter4dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter4dDim3EndToEndTest")
{
    Splitter4dDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClSplitter4dDim0EndToEndUint8Test")
{
    Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClSplitter4dDim1EndToEndUint8Test")
{
    Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClSplitter4dDim2EndToEndUint8Test")
{
    Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClSplitter4dDim3EndToEndUint8Test")
{
    Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

// Tile
TEST_CASE("ClTileEndToEndFloat32")
{
    TileEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClTileEndToEndFloat16")
{
    TileEndToEnd<armnn::DataType::Float16>(clDefaultBackends);
}

TEST_CASE("ClTileEndToEndQAsymmS8")
{
    TileEndToEnd<armnn::DataType::QAsymmS8>(clDefaultBackends);
}

TEST_CASE("ClTileEndToEndQAsymmU8")
{
    TileEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClTileEndToEndQSymmS8")
{
    TileEndToEnd<armnn::DataType::QSymmS8>(clDefaultBackends);
}

TEST_CASE("ClTileEndToEndQSymmS16")
{
    TileEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends);
}

TEST_CASE("ClTileEndToEndSigned32")
{
    TileEndToEnd<armnn::DataType::Signed32>(clDefaultBackends);
}

// TransposeConvolution2d
TEST_CASE("ClTransposeConvolution2dEndToEndFloatNchwTest")
{
    TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
        clDefaultBackends, armnn::DataLayout::NCHW);
}

TEST_CASE("ClTransposeConvolution2dEndToEndUint8NchwTest")
{
    TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
        clDefaultBackends, armnn::DataLayout::NCHW);
}

TEST_CASE("ClTransposeConvolution2dEndToEndFloatNhwcTest")
{
    TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
        clDefaultBackends, armnn::DataLayout::NHWC);
}

TEST_CASE("ClTransposeConvolution2dEndToEndUint8NhwcTest")
{
    TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
        clDefaultBackends, armnn::DataLayout::NHWC);
}

// Transpose
TEST_CASE("ClTransposeEndToEndTest")
{
TransposeEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClQuantizedLstmEndToEndTest")
{
    QuantizedLstmEndToEnd(clDefaultBackends);
}

// ArgMinMax
TEST_CASE("ClArgMaxSimpleTest")
{
    ArgMaxEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMinSimpleTest")
{
    ArgMinEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMaxAxis0Test")
{
    ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMinAxis0Test")
{
    ArgMinAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMaxAxis1Test")
{
    ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMinAxis1Test")
{
    ArgMinAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMaxAxis2Test")
{
    ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMinAxis2Test")
{
    ArgMinAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMaxAxis3Test")
{
    ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMinAxis3Test")
{
    ArgMinAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClArgMaxSimpleTestQAsymmU8")
{
    ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClArgMinSimpleTestQAsymmU8")
{
    ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClArgMaxAxis0TestQAsymmU8")
{
    ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClArgMinAxis0TestQAsymmU8")
{
    ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClArgMaxAxis1TestQAsymmU8")
{
    ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClArgMinAxis1TestQAsymmU8")
{
    ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClArgMaxAxis2TestQAsymmU8")
{
    ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClArgMinAxis2TestQAsymmU8")
{
    ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClArgMaxAxis3TestQAsymmU8")
{
    ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClArgMinAxis3TestQAsymmU8")
{
    ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
}

TEST_CASE("ClQLstmEndToEndTest")
{
    QLstmEndToEnd(clDefaultBackends);
}

TEST_CASE("ClForceImportWithMisalignedInputBuffersEndToEndTest"
          // Currently, the CL workload for activation does not support tensor handle replacement so this test case
          // will always fail.
          * doctest::skip(true))
{
    ForceImportWithMisalignedInputBuffersEndToEndTest(clDefaultBackends);
}

TEST_CASE("ClForceImportWithMisalignedOutputBuffersEndToEndTest"
          // Currently, the CL workload for activation does not support tensor handle replacement so this test case
          // will always fail.
          * doctest::skip(true))
{
    ForceImportWithMisalignedOutputBuffersEndToEndTest(clDefaultBackends);
}

TEST_CASE("ClForceImportWithMisalignedInputAndOutputBuffersEndToEndTest")
{
    ForceImportWithMisalignedInputAndOutputBuffersEndToEndTest(clDefaultBackends);
}

TEST_CASE("ClReshapeRemovalSimpleCaseEndToEnd")
{
    ReshapeRemovalEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
}

TEST_CASE("ClReshapeRemovalNCHWFirstEndToEnd")
{
    ReshapeRemovalNCHWEndToEnd<armnn::DataType::Float32>(clDefaultBackends, false, true);
}

TEST_CASE("ClReshapeRemovalNCHWSecondEndToEnd")
{
    ReshapeRemovalNCHWEndToEnd<armnn::DataType::Float32>(clDefaultBackends, false, false);
}

}