test/Concat.cpp

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

#include "DriverTestHelpers.hpp"
#include "TestTensor.hpp"

#include <array>
#include <log/log.h>

using namespace android::hardware;
using namespace driverTestHelpers;
using namespace armnn_driver;

using HalPolicy = hal_1_0::HalPolicy;
using RequestArgument = V1_0::RequestArgument;

namespace
{

void
ConcatTestImpl(const std::vector<const TestTensor*> & inputs,
                int32_t concatAxis,
                const TestTensor & expectedOutputTensor,
                armnn::Compute computeDevice,
                V1_0::ErrorStatus expectedPrepareStatus=V1_0::ErrorStatus::NONE,
                V1_0::ErrorStatus expectedExecStatus=V1_0::ErrorStatus::NONE)
{
    std::unique_ptr<ArmnnDriver> driver = std::make_unique<ArmnnDriver>(DriverOptions(computeDevice));
    HalPolicy::Model model{};

    hidl_vec<uint32_t> modelInputIds;
    modelInputIds.resize(inputs.size()+1);
    for (uint32_t i = 0; i<inputs.size(); ++i)
    {
        modelInputIds[i] = i;
        AddInputOperand<HalPolicy>(model, inputs[i]->GetDimensions());
    }
    modelInputIds[inputs.size()] = inputs.size(); // add an id for the axis too
    AddIntOperand<HalPolicy>(model, concatAxis);
    AddOutputOperand<HalPolicy>(model, expectedOutputTensor.GetDimensions());

    // make the concat operation
    model.operations.resize(1);
    model.operations[0].type    = HalPolicy::OperationType::CONCATENATION;
    model.operations[0].inputs  = modelInputIds;
    model.operations[0].outputs = hidl_vec<uint32_t>{static_cast<uint32_t>(inputs.size()+1)};

    // make the prepared model
    V1_0::ErrorStatus prepareStatus = V1_0::ErrorStatus::NONE;
    android::sp<V1_0::IPreparedModel> preparedModel = PrepareModelWithStatus(model,
                                                                             *driver,
                                                                             prepareStatus,
                                                                             expectedPrepareStatus);
    DOCTEST_CHECK((int)prepareStatus == (int)expectedPrepareStatus);
    if (prepareStatus != V1_0::ErrorStatus::NONE)
    {
        // prepare failed, we cannot continue
        return;
    }

    DOCTEST_CHECK(preparedModel.get() != nullptr);
    if (preparedModel.get() == nullptr)
    {
        // don't spoil other tests if prepare failed
        return;
    }

    // construct the request
    hidl_vec<RequestArgument> inputArguments;
    hidl_vec<RequestArgument> outputArguments;
    inputArguments.resize(inputs.size());
    outputArguments.resize(1);

    // the request's memory pools will follow the same order as
    // the inputs
    for (uint32_t i = 0; i<inputs.size(); ++i)
    {
        V1_0::DataLocation inloc = {};
        inloc.poolIndex = i;
        inloc.offset = 0;
        inloc.length = inputs[i]->GetNumElements() * sizeof(float);
        RequestArgument input = {};
        input.location = inloc;
        input.dimensions = inputs[i]->GetDimensions();
        inputArguments[i] = input;
    }

    // and an additional memory pool is needed for the output
    {
        V1_0::DataLocation outloc = {};
        outloc.poolIndex = inputs.size();
        outloc.offset = 0;
        outloc.length = expectedOutputTensor.GetNumElements() * sizeof(float);
        RequestArgument output = {};
        output.location = outloc;
        output.dimensions = expectedOutputTensor.GetDimensions();
        outputArguments[0] = output;
    }

    // make the request based on the arguments
    V1_0::Request request = {};
    request.inputs  = inputArguments;
    request.outputs = outputArguments;

    // set the input data
    for (uint32_t i = 0; i<inputs.size(); ++i)
    {
        AddPoolAndSetData(inputs[i]->GetNumElements(),
                            request,
                            inputs[i]->GetData());
    }

    // add memory for the output
    android::sp<IMemory> outMemory = AddPoolAndGetData<float>(expectedOutputTensor.GetNumElements(), request);
    float* outdata = static_cast<float*>(static_cast<void*>(outMemory->getPointer()));

    // run the execution
    DOCTEST_CHECK(preparedModel.get() != nullptr);
    auto execStatus = Execute(preparedModel, request, expectedExecStatus);
    DOCTEST_CHECK((int)execStatus == (int)expectedExecStatus);

    if (execStatus == V1_0::ErrorStatus::NONE)
    {
        // check the result if there was no error
        const float * expectedOutput = expectedOutputTensor.GetData();
        for (unsigned int i=0; i<expectedOutputTensor.GetNumElements();++i)
        {
            DOCTEST_CHECK(outdata[i] == expectedOutput[i]);
        }
    }
}

/// Test cases...
void SimpleConcatAxis0(armnn::Compute computeDevice)
{
    int32_t axis = 0;
    TestTensor aIn{armnn::TensorShape{1, 1, 1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1, 1, 1}, {1}};
    TestTensor cIn{armnn::TensorShape{1, 1, 1, 1}, {2}};

    TestTensor expected{armnn::TensorShape{3, 1, 1, 1}, {0, 1, 2}};
    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void ConcatAxis0NoInterleave(armnn::Compute computeDevice)
{
    int32_t axis = 0;
    TestTensor aIn{armnn::TensorShape{2, 1, 2, 1}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{3, 1, 2, 1}, {4, 5,
                                                    6, 7,
                                                    8, 9}};
    TestTensor cIn{armnn::TensorShape{1, 1, 2, 1}, {10, 11}};

    TestTensor expected{armnn::TensorShape{6, 1, 2, 1}, {0, 1,
                                                         2, 3,
                                                         4, 5,
                                                         6, 7,
                                                         8, 9,
                                                         10, 11}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxis1(armnn::Compute computeDevice)
{
    int32_t axis = 1;
    TestTensor aIn{armnn::TensorShape{1, 1, 1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1, 1, 1}, {1}};
    TestTensor cIn{armnn::TensorShape{1, 1, 1, 1}, {2}};

    TestTensor expected{armnn::TensorShape{1, 3, 1, 1}, {0, 1, 2}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void ConcatAxis1NoInterleave(armnn::Compute computeDevice)
{
    int32_t axis = 1;
    TestTensor aIn{armnn::TensorShape{1, 2, 2, 1}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{1, 3, 2, 1}, {4, 5,
                                                    6, 7,
                                                    8, 9}};
    TestTensor cIn{armnn::TensorShape{1, 1, 2, 1}, {10, 11}};

    TestTensor expected{armnn::TensorShape{1, 6, 2, 1}, {0, 1,
                                                         2, 3,
                                                         4, 5,
                                                         6, 7,
                                                         8, 9,
                                                         10, 11}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxis1DoInterleave(armnn::Compute computeDevice)
{
    int32_t axis = 1;
    TestTensor aIn{armnn::TensorShape{2, 2, 1, 1}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{2, 3, 1, 1}, {4, 5, 6,
                                                    7, 8, 9}};
    TestTensor cIn{armnn::TensorShape{2, 1, 1, 1}, {10,
                                                    11}};

    TestTensor expected{armnn::TensorShape{2, 6, 1, 1}, {0, 1, 4, 5, 6, 10,
                                                         2, 3, 7, 8, 9, 11}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxis2(armnn::Compute computeDevice)
{
    int32_t axis = 2;
    TestTensor aIn{armnn::TensorShape{1, 1, 1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1, 1, 1}, {1}};
    TestTensor cIn{armnn::TensorShape{1, 1, 1, 1}, {2}};

    TestTensor expected{armnn::TensorShape{1, 1, 3, 1}, {0, 1, 2}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void ConcatAxis2NoInterleave(armnn::Compute computeDevice)
{
    int32_t axis = 2;
    TestTensor aIn{armnn::TensorShape{1, 1, 2, 2}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{1, 1, 3, 2}, {4, 5,
                                                    6, 7,
                                                    8, 9}};
    TestTensor cIn{armnn::TensorShape{1, 1, 1, 2}, {10, 11}};

    TestTensor expected{armnn::TensorShape{1, 1, 6, 2}, {0, 1,
                                                         2, 3,
                                                         4, 5,
                                                         6, 7,
                                                         8, 9,
                                                         10, 11}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxis2DoInterleave(armnn::Compute computeDevice)
{
    int32_t axis = 2;
    TestTensor aIn{armnn::TensorShape{1, 2, 2, 1}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{1, 2, 3, 1}, {4, 5, 6,
                                                    7, 8, 9}};
    TestTensor cIn{armnn::TensorShape{1, 2, 1, 1}, {10,
                                                    11}};

    TestTensor expected{armnn::TensorShape{1, 2, 6, 1}, {0, 1, 4, 5, 6, 10,
                                                         2, 3, 7, 8, 9, 11}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxis3(armnn::Compute computeDevice)
{
    int32_t axis = 3;
    TestTensor aIn{armnn::TensorShape{1, 1, 1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1, 1, 1}, {1}};
    TestTensor cIn{armnn::TensorShape{1, 1, 1, 1}, {2}};

    TestTensor expected{armnn::TensorShape{1, 1, 1, 3}, {0, 1, 2}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxis3DoInterleave(armnn::Compute computeDevice)
{
    int32_t axis = 3;
    TestTensor aIn{armnn::TensorShape{1, 1, 2, 2}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{1, 1, 2, 3}, {4, 5, 6,
                                                    7, 8, 9}};
    TestTensor cIn{armnn::TensorShape{1, 1, 2, 1}, {10,
                                                    11}};

    TestTensor expected{armnn::TensorShape{1, 1, 2, 6}, {0, 1, 4, 5, 6, 10,
                                                         2, 3, 7, 8, 9, 11}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void AxisTooBig(armnn::Compute computeDevice)
{
    int32_t axis = 4;
    TestTensor aIn{armnn::TensorShape{1, 1, 1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1, 1, 1}, {0}};

    // The axis must be within the range of [-rank(values), rank(values))
    // see: https://www.tensorflow.org/api_docs/python/tf/concat
    TestTensor uncheckedOutput{armnn::TensorShape{1, 1, 1, 1}, {0}};
    V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
    ConcatTestImpl({&aIn, &bIn}, axis, uncheckedOutput, computeDevice, expectedParserStatus);
}

void AxisTooSmall(armnn::Compute computeDevice)
{
    int32_t axis = -5;
    TestTensor aIn{armnn::TensorShape{1, 1, 1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1, 1, 1}, {0}};

    // The axis must be within the range of [-rank(values), rank(values))
    // see: https://www.tensorflow.org/api_docs/python/tf/concat
    TestTensor uncheckedOutput{armnn::TensorShape{1, 1, 1, 1}, {0}};
    V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
    ConcatTestImpl({&aIn, &bIn}, axis, uncheckedOutput, computeDevice, expectedParserStatus);
}

void TooFewInputs(armnn::Compute computeDevice)
{
    int32_t axis = 0;
    TestTensor aIn{armnn::TensorShape{1, 1, 1, 1}, {0}};

    // We need at least two tensors to concatenate
    V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
    ConcatTestImpl({&aIn}, axis, aIn, computeDevice, expectedParserStatus);
}

void MismatchedInputDimensions(armnn::Compute computeDevice)
{
    int32_t axis = 3;
    TestTensor aIn{armnn::TensorShape{1, 1, 2, 2}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{1, 1, 2, 3}, {4, 5, 6,
                                                    7, 8, 9}};
    TestTensor mismatched{armnn::TensorShape{1, 1, 1, 1}, {10}};

    TestTensor expected{armnn::TensorShape{1, 1, 2, 6}, {0, 1, 4, 5, 6, 10,
                                                         2, 3, 7, 8, 9, 11}};

    // The input dimensions must be compatible
    V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
    ConcatTestImpl({&aIn, &bIn, &mismatched}, axis, expected, computeDevice, expectedParserStatus);
}

void MismatchedInputRanks(armnn::Compute computeDevice)
{
    int32_t axis = 2;
    TestTensor aIn{armnn::TensorShape{1, 1, 2}, {0, 1}};
    TestTensor bIn{armnn::TensorShape{1, 1}, {4}};
    TestTensor expected{armnn::TensorShape{1, 1, 3}, {0, 1, 4}};

    // The input dimensions must be compatible
    V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
    ConcatTestImpl({&aIn, &bIn}, axis, expected, computeDevice, expectedParserStatus);
}

void MismatchedOutputDimensions(armnn::Compute computeDevice)
{
    int32_t axis = 3;
    TestTensor aIn{armnn::TensorShape{1, 1, 2, 2}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{1, 1, 2, 3}, {4, 5, 6,
                                                    7, 8, 9}};
    TestTensor cIn{armnn::TensorShape{1, 1, 2, 1}, {10,
                                                    11}};

    TestTensor mismatched{armnn::TensorShape{1, 1, 6, 2}, {0, 1, 4, 5, 6, 10,
                                                           2, 3, 7, 8, 9, 11}};

    // The input and output dimensions must be compatible
    V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, mismatched, computeDevice, expectedParserStatus);
}

void MismatchedOutputRank(armnn::Compute computeDevice)
{
    int32_t axis = 3;
    TestTensor aIn{armnn::TensorShape{1, 1, 2, 2}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{1, 1, 2, 3}, {4, 5, 6,
                                                    7, 8, 9}};
    TestTensor cIn{armnn::TensorShape{1, 1, 2, 1}, {10,
                                                    11}};

    TestTensor mismatched{armnn::TensorShape{6, 2}, {0, 1, 4, 5, 6, 10,
                                                     2, 3, 7, 8, 9, 11}};

    // The input and output ranks must match
    V1_0::ErrorStatus expectedParserStatus = V1_0::ErrorStatus::GENERAL_FAILURE;
    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, mismatched, computeDevice, expectedParserStatus);
}

void ValidNegativeAxis(armnn::Compute computeDevice)
{
    // this is the same as 3
    // see: https://www.tensorflow.org/api_docs/python/tf/concat
    int32_t axis = -1;
    TestTensor aIn{armnn::TensorShape{1, 1, 2, 2}, {0, 1,
                                                    2, 3}};
    TestTensor bIn{armnn::TensorShape{1, 1, 2, 3}, {4, 5, 6,
                                                    7, 8, 9}};
    TestTensor cIn{armnn::TensorShape{1, 1, 2, 1}, {10,
                                                    11}};

    TestTensor expected{armnn::TensorShape{1, 1, 2, 6}, {0, 1, 4, 5, 6, 10,
                                                         2, 3, 7, 8, 9, 11}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxisZero3D(armnn::Compute computeDevice)
{
    int32_t axis = 0;
    TestTensor aIn{armnn::TensorShape{1, 1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1, 1}, {1}};
    TestTensor cIn{armnn::TensorShape{1, 1, 1}, {2}};

    TestTensor expected{armnn::TensorShape{3, 1, 1}, {0, 1, 2}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxisOne3D(armnn::Compute computeDevice)
{
    int32_t axis = 1;
    TestTensor aIn{armnn::TensorShape{1, 1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1, 1}, {1}};
    TestTensor cIn{armnn::TensorShape{1, 1, 1}, {2}};

    TestTensor expected{armnn::TensorShape{1, 3, 1}, {0, 1, 2}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxisTwo3D(armnn::Compute computeDevice)
{
    int32_t axis = 2;
    TestTensor aIn{armnn::TensorShape{1, 1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1, 1}, {1}};
    TestTensor cIn{armnn::TensorShape{1, 1, 1}, {2}};

    TestTensor expected{armnn::TensorShape{1, 1, 3}, {0, 1, 2}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxisZero2D(armnn::Compute computeDevice)
{
    int32_t axis = 0;
    TestTensor aIn{armnn::TensorShape{1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1}, {1}};
    TestTensor cIn{armnn::TensorShape{1, 1}, {2}};

    TestTensor expected{armnn::TensorShape{3, 1}, {0, 1, 2}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxisOne2D(armnn::Compute computeDevice)
{
    int32_t axis = 1;
    TestTensor aIn{armnn::TensorShape{1, 1}, {0}};
    TestTensor bIn{armnn::TensorShape{1, 1}, {1}};
    TestTensor cIn{armnn::TensorShape{1, 1}, {2}};

    TestTensor expected{armnn::TensorShape{1, 3}, {0, 1, 2}};

    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

void SimpleConcatAxisZero1D(armnn::Compute computeDevice)
{
    int32_t axis = 0;
    TestTensor aIn{armnn::TensorShape{1}, {0}};
    TestTensor bIn{armnn::TensorShape{1}, {1}};
    TestTensor cIn{armnn::TensorShape{1}, {2}};

    TestTensor expected{armnn::TensorShape{3}, {0, 1, 2}};
    ConcatTestImpl({&aIn, &bIn, &cIn}, axis, expected, computeDevice);
}

} // namespace <anonymous>

DOCTEST_TEST_SUITE("ConcatTests_CpuRef")
{

DOCTEST_TEST_CASE("SimpleConcatAxis0")
{
    SimpleConcatAxis0(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("ConcatAxis0NoInterleave")
{
    ConcatAxis0NoInterleave(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxis1")
{
    SimpleConcatAxis1(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("ConcatAxis1NoInterleave")
{
    ConcatAxis1NoInterleave(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxis1DoInterleave")
{
    SimpleConcatAxis1DoInterleave(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxis2")
{
    SimpleConcatAxis2(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("ConcatAxis2NoInterleave")
{
    ConcatAxis2NoInterleave(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxis2DoInterleave")
{
    SimpleConcatAxis2DoInterleave(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxis3")
{
    SimpleConcatAxis3(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxis3DoInterleave")
{
    SimpleConcatAxis3DoInterleave(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("AxisTooBig")
{
    AxisTooBig(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("AxisTooSmall")
{
    AxisTooSmall(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("TooFewInputs")
{
    TooFewInputs(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("MismatchedInputDimensions")
{
    MismatchedInputDimensions(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("MismatchedInputRanks")
{
    MismatchedInputRanks(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("MismatchedOutputDimensions")
{
    MismatchedOutputDimensions(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("MismatchedOutputRank")
{
    MismatchedOutputRank(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("ValidNegativeAxis")
{
    ValidNegativeAxis(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxisZero3D")
{
    SimpleConcatAxisZero3D(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxisOne3D")
{
    SimpleConcatAxisOne3D(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxisTwo3D")
{
    SimpleConcatAxisTwo3D(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxisZero2D")
{
    SimpleConcatAxisZero2D(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxisOne2D")
{
    SimpleConcatAxisOne2D(armnn::Compute::CpuRef);
}

DOCTEST_TEST_CASE("SimpleConcatAxisZero1D")
{
    SimpleConcatAxisZero1D(armnn::Compute::CpuRef);
}

}

#ifdef ARMCOMPUTECL_ENABLED
DOCTEST_TEST_SUITE("ConcatTests_GpuAcc")
{

DOCTEST_TEST_CASE("SimpleConcatAxis0")
{
    SimpleConcatAxis0(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("ConcatAxis0NoInterleave")
{
    ConcatAxis0NoInterleave(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxis1")
{
    SimpleConcatAxis1(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("ConcatAxis1NoInterleave")
{
    ConcatAxis1NoInterleave(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxis1DoInterleave")
{
    SimpleConcatAxis1DoInterleave(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxis2")
{
    SimpleConcatAxis2(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("ConcatAxis2NoInterleave")
{
    ConcatAxis2NoInterleave(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxis2DoInterleave")
{
    SimpleConcatAxis2DoInterleave(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxis3")
{
    SimpleConcatAxis3(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxis3DoInterleave")
{
    SimpleConcatAxis3DoInterleave(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("AxisTooBig")
{
    AxisTooBig(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("AxisTooSmall")
{
    AxisTooSmall(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("TooFewInputs")
{
    TooFewInputs(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("MismatchedInputDimensions")
{
    MismatchedInputDimensions(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("MismatchedInputRanks")
{
    MismatchedInputRanks(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("MismatchedOutputDimensions")
{
    MismatchedOutputDimensions(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("MismatchedOutputRank")
{
    MismatchedOutputRank(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("ValidNegativeAxis")
{
    ValidNegativeAxis(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxisZero3D")
{
    SimpleConcatAxisZero3D(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxisOne3D")
{
    SimpleConcatAxisOne3D(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxisTwo3D")
{
    SimpleConcatAxisTwo3D(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxisZero2D")
{
    SimpleConcatAxisZero2D(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxisOne2D")
{
    SimpleConcatAxisOne2D(armnn::Compute::GpuAcc);
}

DOCTEST_TEST_CASE("SimpleConcatAxisZero1D")
{
    SimpleConcatAxisZero1D(armnn::Compute::GpuAcc);
}

}// End of GpuAcc Test Suite
#endif