friendlyelec
/
rk35xx-android14
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
rk35xx-android14/external/android-nn-driver/test/Concat.cpp

733 lines
23 KiB
Raw Permalink Blame History

//
// 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
Reference in new issue View Git Blame Copy Permalink