Function PadTest

delegate/test/PadTestHelper.hpp:157–204

template <typename T>
void PadTest(tflite::BuiltinOperator padOperatorCode,
             tflite::TensorType tensorType,
             const std::vector<int32_t>& inputShape,
             const std::vector<int32_t>& paddingShape,
             std::vector<int32_t>& outputShape,
             std::vector<T>& inputValues,
             std::vector<int32_t>& paddingDim,
             std::vector<T>& expectedOutputValues,
             T paddingValue,
             const std::vector<armnn::BackendId>& backends = {},
             float quantScale = 1.0f,
             int quantOffset  = 0,
             tflite::MirrorPadMode paddingMode = tflite::MirrorPadMode_SYMMETRIC)
{
    using namespace delegateTestInterpreter;
    std::vector<char> modelBuffer = CreatePadTfLiteModel<T>(padOperatorCode,
                                                            tensorType,
                                                            paddingMode,
                                                            inputShape,
                                                            paddingShape,
                                                            outputShape,
                                                            paddingDim,
                                                            {paddingValue},
                                                            quantScale,
                                                            quantOffset);

    // Setup interpreter with just TFLite Runtime.
    auto tfLiteInterpreter = DelegateTestInterpreter(modelBuffer);
    CHECK(tfLiteInterpreter.AllocateTensors() == kTfLiteOk);
    CHECK(tfLiteInterpreter.FillInputTensor<T>(inputValues, 0) == kTfLiteOk);
    CHECK(tfLiteInterpreter.Invoke() == kTfLiteOk);
    std::vector<T>       tfLiteOutputValues = tfLiteInterpreter.GetOutputResult<T>(0);
    std::vector<int32_t> tfLiteOutputShape  = tfLiteInterpreter.GetOutputShape(0);

    // Setup interpreter with Arm NN Delegate applied.
    auto armnnInterpreter = DelegateTestInterpreter(modelBuffer, CaptureAvailableBackends(backends));
    CHECK(armnnInterpreter.AllocateTensors() == kTfLiteOk);
    CHECK(armnnInterpreter.FillInputTensor<T>(inputValues, 0) == kTfLiteOk);
    CHECK(armnnInterpreter.Invoke() == kTfLiteOk);
    std::vector<T>       armnnOutputValues = armnnInterpreter.GetOutputResult<T>(0);
    std::vector<int32_t> armnnOutputShape  = armnnInterpreter.GetOutputShape(0);

    armnnDelegate::CompareOutputData<T>(tfLiteOutputValues, armnnOutputValues, expectedOutputValues);
    armnnDelegate::CompareOutputShape(tfLiteOutputShape, armnnOutputShape, outputShape);

    tfLiteInterpreter.Cleanup();
    armnnInterpreter.Cleanup();
}

} // anonymous namespace