/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "TestNeuralNetworksWrapper.h"

#include <sys/mman.h>
#include <tuple>
#include <vector>

#include <android-base/macros.h>
#include <android/sharedmem.h>
#include <gtest/gtest.h>

using namespace android::nn::test_wrapper;

namespace {

// We try the following model:
//
//     op2 = ADD(op0, op1)
//     op4 = TRANSPOSE(op2, op3)
//
// where op0 is a required model input, should be of dimension (A, B).
//       op1 is a required constant, should be of dimension (A, 1).
//       op2 is an internal operand, should be of dimension (A, B).
//       op3 is an omitted optional constant / model input, should be of dimension (2).
//       op4 is a model output, should be of dimension (B, A).
//
// For each operand, we test combinations of dimensions specification level during model
// construction time and execution time (if any). All other relevant combinations of the
// basic scenarios are then iterated over in TestAll. Note that we don't want to just use
// googletest's parametrized tests (TEST_P) as the 16k combinations generated too many
// lines of output for the test infrastructure to handle correctly.

// Which operand to test
enum class UnspecifiedOperand {
    INPUT_MANDATORY,
    CONST_MANDATORY,
    TEMPORARY_VARIABLE,
    INPUT_OPTIONAL,
    CONST_OPTIONAL,
    OUTPUT
};
// How well the dimensional information is specified
enum class SpecificationLevel {
    FULLY_SPECIFIED,   // all dimensions are clearly specified without any ambiguity
    UNSPECIFIED_DIM,   // certain dimension is set to 0 as unknown, but rank is well-specified
    UNSPECIFIED_RANK,  // rank is set to 0 as unknown, passing an empty vector for dims
    UNSPECIFIED_TYPE   // only during execution time, passing nullptr for operand type
};
using UnspecifiedDimensionsTestParam = std::tuple<UnspecifiedOperand,
                                                  SpecificationLevel,   // model construction time
                                                  SpecificationLevel>;  // execution time

// Indexing
constexpr uint32_t kIndex0_Model = 0;      // op0, model
constexpr uint32_t kIndex1_Model = 1;      // op1, model
constexpr uint32_t kIndex2_Model = 2;      // op2, model
constexpr uint32_t kIndex3_Model = 3;      // op3, model
constexpr uint32_t kIndex4_Model = 4;      // op4, model
constexpr uint32_t kIndex0_Execution = 5;  // op0, execution
constexpr uint32_t kIndex3_Execution = 6;  // op3, execution
constexpr uint32_t kIndex4_Execution = 7;  // op4, execution
constexpr uint32_t kIndexCount = 8;        // count

constexpr int32_t kValueA = 0;
constexpr int32_t kValueB = 2;
constexpr uint32_t kDimAGood = 2;
constexpr uint32_t kDimABad = 3;

class UnspecifiedDimensionsTest : public ::testing::TestWithParam<UnspecifiedDimensionsTestParam> {
    enum class OptionalType { CONST, INPUT };       // omitted operand op3 is an input or const
    enum class BufferSize { LESS, EQUAL, MORE };    // only used for output buffer size
    enum class OperandLocation { BUFFER, MEMORY };  // where the operand reside
    enum class InOutType { INPUT, OUTPUT };         // parameter for setInOut()

    class SharedMemoryForTest {
       public:
        SharedMemoryForTest() : memory(nullptr), fd(-1), buffer(nullptr), length(0) {}
        ~SharedMemoryForTest() {
            if (buffer != nullptr) {
                munmap(buffer, length);
            }
            if (fd > -1) {
                close(fd);
            }
        }
        void initialize(size_t size, const void* data) {
            length = size;
            fd = ASharedMemory_create(nullptr, size);
            ASSERT_GT(fd, -1);
            buffer = (uint8_t*)mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
            ASSERT_NE(buffer, nullptr);
            memcpy(buffer, data, size);
            memory = std::make_shared<Memory>(size, PROT_READ | PROT_WRITE, fd, 0);
            ASSERT_TRUE(memory->isValid());
        }
        const Memory* getMemory() const { return memory.get(); }
        const uint8_t* getBuffer() const { return buffer; }

       private:
        DISALLOW_COPY_AND_ASSIGN(SharedMemoryForTest);
        std::shared_ptr<Memory> memory;
        int fd;
        uint8_t* buffer;
        size_t length;
    };

    std::string toString(SpecificationLevel level) {
        switch (level) {
            case SpecificationLevel::FULLY_SPECIFIED:
                return "FULLY_SPECIFIED";
            case SpecificationLevel::UNSPECIFIED_DIM:
                return "UNSPECIFIED_DIM";
            case SpecificationLevel::UNSPECIFIED_RANK:
                return "UNSPECIFIED_RANK";
            case SpecificationLevel::UNSPECIFIED_TYPE:
                return "UNSPECIFIED_TYPE";
            default:
                return "UNKNOWN";
        }
    }

    std::string toString(BufferSize b) {
        switch (b) {
            case BufferSize::LESS:
                return "LESS";
            case BufferSize::EQUAL:
                return "EQUAL";
            case BufferSize::MORE:
                return "MORE";
            default:
                return "UNKNOWN";
        }
    }

    std::string toString(OperandLocation loc) {
        switch (loc) {
            case OperandLocation::BUFFER:
                return "BUFFER";
            case OperandLocation::MEMORY:
                return "MEMORY";
            default:
                return "UNKNOWN";
        }
    }

   protected:
    virtual void SetUp() {
        uint32_t modelIndex, executionIndex;
        switch (kUnspecifiedOperand) {
            case UnspecifiedOperand::INPUT_MANDATORY:
                modelIndex = kIndex0_Model;
                executionIndex = kIndex0_Execution;
                mBadIndexChoices = {kIndexCount, modelIndex, executionIndex};
                mOperandLocationChoices = {OperandLocation::BUFFER, OperandLocation::MEMORY};
                break;
            case UnspecifiedOperand::CONST_MANDATORY:
                modelIndex = kIndex1_Model;
                executionIndex = kIndexCount;
                mBadIndexChoices = {kIndexCount, modelIndex};
                mOperandLocationChoices = {OperandLocation::BUFFER, OperandLocation::MEMORY};
                break;
            case UnspecifiedOperand::TEMPORARY_VARIABLE:
                modelIndex = kIndex2_Model;
                executionIndex = kIndexCount;
                mBadIndexChoices = {kIndexCount, modelIndex};
                mOperandLocationChoices = {OperandLocation::BUFFER};
                break;
            case UnspecifiedOperand::INPUT_OPTIONAL:
                modelIndex = kIndex3_Model;
                executionIndex = kIndex3_Execution;
                mBadIndexChoices = {kIndexCount};
                mOptionalType = OptionalType::INPUT;
                mOperandLocationChoices = {OperandLocation::BUFFER};
                break;
            case UnspecifiedOperand::CONST_OPTIONAL:
                modelIndex = kIndex3_Model;
                executionIndex = kIndexCount;
                mBadIndexChoices = {kIndexCount};
                mOperandLocationChoices = {OperandLocation::BUFFER};
                break;
            case UnspecifiedOperand::OUTPUT:
                modelIndex = kIndex4_Model;
                executionIndex = kIndex4_Execution;
                mBadIndexChoices = {kIndexCount, modelIndex, executionIndex};
                mOperandLocationChoices = {OperandLocation::BUFFER, OperandLocation::MEMORY};
                mBufferSizeChoices = {BufferSize::LESS, BufferSize::EQUAL, BufferSize::MORE};
                break;
            default:
                break;
        }
        std::vector<SpecificationLevel> levels{
                SpecificationLevel::UNSPECIFIED_DIM, SpecificationLevel::FULLY_SPECIFIED,
                SpecificationLevel::UNSPECIFIED_DIM, SpecificationLevel::FULLY_SPECIFIED,
                SpecificationLevel::UNSPECIFIED_DIM, SpecificationLevel::FULLY_SPECIFIED,
                SpecificationLevel::FULLY_SPECIFIED, SpecificationLevel::FULLY_SPECIFIED};
        levels[modelIndex] = kSpecificationLevelModel;
        if (executionIndex < kIndexCount) {
            levels[executionIndex] = kSpecificationLevelExecution;
        }
        mSpecificationLevels = std::move(levels);
    }

    OperandType getType(uint32_t index, const std::vector<uint32_t>& dim) {
        const SpecificationLevel l = mSpecificationLevels[index];
        std::vector<uint32_t> setDim;
        if (l != SpecificationLevel::UNSPECIFIED_RANK) {
            for (auto d : dim) {
                if (d == 0) {
                    setDim.push_back(mBadIndex != index ? kDimAGood : kDimABad);
                } else {
                    setDim.push_back(l == SpecificationLevel::FULLY_SPECIFIED ? d : 0);
                }
            }
        }
        float scale = mOperandTypes[index] == Type::TENSOR_QUANT8_ASYMM ? 1.0 : 0.0;
        return OperandType(mOperandTypes[index], setDim, scale, 0);
    }

    uint32_t getSize(uint32_t index, const std::vector<uint32_t>& dim,
                     BufferSize s = BufferSize::EQUAL) {
        uint32_t n = 1;
        for (auto d : dim) {
            n *= (d == 0 ? (mBadIndex != index ? kDimAGood : kDimABad) : d);
        }
        if (s == BufferSize::LESS) {
            n /= 2;
        } else if (s == BufferSize::MORE) {
            n *= 2;
        }
        return n;
    };

    template <typename T>
    Result setInOut(Execution* execution, uint32_t index, uint32_t opIndex,
                    const std::vector<uint32_t>& dim, void* buffer,
                    const SharedMemoryForTest* memory, InOutType inOutType,
                    BufferSize bufferSize = BufferSize::EQUAL) {
        const auto kLevel = mSpecificationLevels[index];
        size_t size = (buffer == nullptr) ? 0 : getSize(index, dim, bufferSize) * sizeof(T);
        auto type = getType(index, dim);
        ANeuralNetworksOperandType* t =
                (kLevel == SpecificationLevel::UNSPECIFIED_TYPE) ? nullptr : &type.operandType;
        if (mOperandLocation == OperandLocation::MEMORY && memory != nullptr) {
            if (inOutType == InOutType::INPUT) {
                return execution->setInputFromMemory(opIndex, memory->getMemory(), 0, size, t);
            } else {
                return execution->setOutputFromMemory(opIndex, memory->getMemory(), 0, size, t);
            }
        } else {
            if (inOutType == InOutType::INPUT) {
                return execution->setInput(opIndex, buffer, size, t);
            } else {
                return execution->setOutput(opIndex, buffer, size, t);
            }
        }
        return Result::NO_ERROR;
    }

    template <typename T, Type TensorType>
    void TestOne() {
        // Phase 1: Build Model
        Model model;
        auto type0 = getType(kIndex0_Model, {kValueA, kValueB});
        auto type1 = getType(kIndex1_Model, {kValueA, 1});
        auto type2 = getType(kIndex2_Model, {kValueA, kValueB});
        auto type3 = getType(kIndex3_Model, {2});
        auto type4 = getType(kIndex4_Model, {kValueB, kValueA});
        OperandType typeActivation(Type::INT32, {});  // activation

        auto op0 = model.addOperand(&type0);
        auto op1 = model.addOperand(&type1);
        auto op2 = model.addOperand(&type2);
        auto op3 = model.addOperand(&type3);
        auto op4 = model.addOperand(&type4);
        auto act = model.addOperand(&typeActivation);

        T bufferOp1[2] = {1, 2};
        SharedMemoryForTest memoryOp1;
        memoryOp1.initialize(sizeof(bufferOp1), bufferOp1);
        if (mOperandLocation == OperandLocation::BUFFER) {
            model.setOperandValue(op1, bufferOp1, sizeof(bufferOp1));
        } else {
            model.setOperandValueFromMemory(op1, memoryOp1.getMemory(), 0, sizeof(bufferOp1));
        }
        int32_t kActivation = 0;
        model.setOperandValue(act, &kActivation, sizeof(int32_t));
        if (mOptionalType == OptionalType::CONST) {
            model.setOperandValue(op3, nullptr, 0);
        }

        model.addOperation(ANEURALNETWORKS_ADD, {op0, op1, act}, {op2});
        model.addOperation(ANEURALNETWORKS_TRANSPOSE, {op2, op3}, {op4});
        if (mOptionalType == OptionalType::CONST) {
            model.identifyInputsAndOutputs({op0}, {op4});
        } else {
            model.identifyInputsAndOutputs({op0, op3}, {op4});
        }

        bool expected = expectModelIsValid();
        ASSERT_EQ(model.isValid(), expected);
        Result result = model.finish();
        if (expected) {
            ASSERT_EQ(result, Result::NO_ERROR);
        } else {
            // There is no contract (yet) for specific errors in NeuralNetworks.h,
            // so we just assert on not being successful.
            ASSERT_NE(result, Result::NO_ERROR);
            return;
        }

        // Phase 2: Compile Model, should always pass
        Compilation compilation(&model);
        ASSERT_EQ(compilation.finish(), Result::NO_ERROR);

        std::vector<uint32_t> valueBChoices = {1, 2};
        for (const auto valueB : valueBChoices) {
            SCOPED_TRACE("ValueB: " + std::to_string(valueB));
            if (valueB != kValueB &&
                (mSpecificationLevels[kIndex0_Model] == SpecificationLevel::FULLY_SPECIFIED ||
                 mSpecificationLevels[kIndex2_Model] == SpecificationLevel::FULLY_SPECIFIED ||
                 mSpecificationLevels[kIndex4_Model] == SpecificationLevel::FULLY_SPECIFIED)) {
                continue;
            }

            // Phase 3: Set Execution Input/Output
            Execution execution(&compilation);

            // Set input0
            Result result;
            T bufferOp0[6] = {1, 2, 3, 4, 5, 6};
            SharedMemoryForTest memoryOp0;
            memoryOp0.initialize(sizeof(bufferOp0), bufferOp0);
            result = setInOut<T>(&execution, kIndex0_Execution, 0, {kValueA, valueB}, bufferOp0,
                                 &memoryOp0, InOutType::INPUT);
            ASSERT_EQ(result, expectSetInput0());
            if (result != Result::NO_ERROR) continue;

            // Set input1, omitted
            if (mOptionalType == OptionalType::INPUT) {
                result = setInOut<T>(&execution, kIndex3_Execution, 1, {2}, nullptr, nullptr,
                                     InOutType::INPUT);
                ASSERT_EQ(result, expectSetInput1());
                if (result != Result::NO_ERROR) continue;
            }

            // Set output0
            T bufferOp4[16];
            SharedMemoryForTest memoryOp4;
            memoryOp4.initialize(sizeof(bufferOp4), bufferOp4);
            result = setInOut<T>(&execution, kIndex4_Execution, 0, {valueB, kValueA}, bufferOp4,
                                 &memoryOp4, InOutType::OUTPUT, mOutputBufferSize);
            ASSERT_EQ(result, expectSetOutput0());
            if (result != Result::NO_ERROR) continue;

            // Phase 4: Compute and Compare Results
            result = execution.compute();
            ASSERT_EQ(result, expectCompute());
            if (result == Result::OP_FAILED) continue;

            std::vector<uint32_t> outputShape;
            ASSERT_EQ(execution.getOutputOperandDimensions(0, &outputShape), result);
            std::vector<uint32_t> expectedOutputShape = {valueB, kDimAGood};
            ASSERT_EQ(outputShape, expectedOutputShape);
            if (result == Result::OUTPUT_INSUFFICIENT_SIZE) continue;

            const T* outputBuffer = mOperandLocation == OperandLocation::MEMORY
                                            ? reinterpret_cast<const T*>(memoryOp4.getBuffer())
                                            : bufferOp4;
            T expected_1x2[2] = {2, 4};
            T expected_2x2[4] = {2, 5, 3, 6};
            for (uint32_t i = 0; i < kDimAGood * valueB; i++) {
                ASSERT_EQ(outputBuffer[i], valueB == 1 ? expected_1x2[i] : expected_2x2[i]);
            }
        }
    }

    // Expect invalid model for the following cases
    // - op1 is not fully specified (const operand must be fully specified)
    // - op1 has bad dimension value (const operand size is checked with buffer size)
    bool expectModelIsValid() {
        const auto kLevel1_Model = mSpecificationLevels[kIndex1_Model];
        if (kLevel1_Model != SpecificationLevel::FULLY_SPECIFIED || mBadIndex == kIndex1_Model) {
            return false;
        }
        return true;
    }

    // Expect BAD_DATA on input0 for the following cases
    // - the provided type is not fully specified
    // - the provided type does not agree with the type set at model construction time
    // - no type is provided and the type is not fully specified at model construction time
    Result expectSetInput0() {
        const auto kLevel0_Model = mSpecificationLevels[kIndex0_Model];
        const auto kLevel0_Execution = mSpecificationLevels[kIndex0_Execution];
        switch (kLevel0_Execution) {
            case SpecificationLevel::UNSPECIFIED_DIM:
            case SpecificationLevel::UNSPECIFIED_RANK:
                return Result::BAD_DATA;
            case SpecificationLevel::FULLY_SPECIFIED:
                if ((mBadIndex == kIndex0_Execution || mBadIndex == kIndex0_Model) &&
                    kLevel0_Model != SpecificationLevel::UNSPECIFIED_RANK) {
                    return Result::BAD_DATA;
                }
                break;
            case SpecificationLevel::UNSPECIFIED_TYPE:
                if (kLevel0_Model == SpecificationLevel::UNSPECIFIED_DIM ||
                    kLevel0_Model == SpecificationLevel::UNSPECIFIED_RANK ||
                    mBadIndex == kIndex0_Model) {
                    return Result::BAD_DATA;
                }
                break;
            default:
                break;
        }
        return Result::NO_ERROR;
    }

    // Expect BAD_DATA on input1 for the following cases
    // - the provided type is less detailed as the type set at model construction time
    Result expectSetInput1() {
        const auto kLevel3_Model = mSpecificationLevels[kIndex3_Model];
        const auto kLevel3_Execution = mSpecificationLevels[kIndex3_Execution];
        switch (kLevel3_Execution) {
            case SpecificationLevel::UNSPECIFIED_DIM:
                if (kLevel3_Model == SpecificationLevel::FULLY_SPECIFIED) {
                    return Result::BAD_DATA;
                }
                break;
            case SpecificationLevel::UNSPECIFIED_RANK:
                if (kLevel3_Model != SpecificationLevel::UNSPECIFIED_RANK) {
                    return Result::BAD_DATA;
                }
                break;
            default:
                break;
        }
        return Result::NO_ERROR;
    }

    // Expect BAD_DATA on output0 for the following cases
    // - the provided type is less detailed as the type set at model construction time
    // - the provided type does not agree with the type set at model construction time
    // - the buffer size does not agree with a fully specified type
    Result expectSetOutput0() {
        const auto kLevel4_Model = mSpecificationLevels[kIndex4_Model];
        const auto kLevel4_Execution = mSpecificationLevels[kIndex4_Execution];
        switch (kLevel4_Execution) {
            case SpecificationLevel::UNSPECIFIED_DIM:
                if (kLevel4_Model == SpecificationLevel::FULLY_SPECIFIED ||
                    (kLevel4_Model == SpecificationLevel::UNSPECIFIED_DIM &&
                     (mBadIndex == kIndex4_Model || mBadIndex == kIndex4_Execution))) {
                    return Result::BAD_DATA;
                }
                break;
            case SpecificationLevel::UNSPECIFIED_RANK:
                if (kLevel4_Model != SpecificationLevel::UNSPECIFIED_RANK) {
                    return Result::BAD_DATA;
                }
                break;
            case SpecificationLevel::FULLY_SPECIFIED:
                if (((mBadIndex == kIndex4_Model || mBadIndex == kIndex4_Execution) &&
                     kLevel4_Model != SpecificationLevel::UNSPECIFIED_RANK) ||
                    mOutputBufferSize != BufferSize::EQUAL) {
                    return Result::BAD_DATA;
                }
                break;
            case SpecificationLevel::UNSPECIFIED_TYPE:
                if (kLevel4_Model == SpecificationLevel::FULLY_SPECIFIED &&
                    (mOutputBufferSize != BufferSize::EQUAL || mBadIndex == kIndex4_Model ||
                     mBadIndex == kIndex4_Execution)) {
                    return Result::BAD_DATA;
                }
                break;
            default:
                break;
        }
        return Result::NO_ERROR;
    }

    // Expect failure for the following cases
    // - one of the operands has bad dimension -> OP_FAILED
    // - insufficient output buffer -> OUTPUT_INSUFFICIENT_SIZE
    Result expectCompute() {
        if (mBadIndex < 8) {
            return Result::OP_FAILED;
        } else if (mOutputBufferSize == BufferSize::LESS) {
            return Result::OUTPUT_INSUFFICIENT_SIZE;
        }
        return Result::NO_ERROR;
    }

    // Iterate over combinations of
    // - mBadIndexChoices: which operand has incorrect dimension
    // - mOperandLocationChoices: where the operand reside, buffer or shared memory
    // - mBufferSizeChoices: whether the provided output buffer/memory size is sufficient
    template <typename T, Type TensorType>
    void TestAll() {
        SCOPED_TRACE("Model: " + toString(kSpecificationLevelModel));
        SCOPED_TRACE("Execution: " + toString(kSpecificationLevelExecution));
        mOperandTypes = {TensorType, TensorType, TensorType,         Type::TENSOR_INT32,
                         TensorType, TensorType, Type::TENSOR_INT32, TensorType};
        for (const auto kBadIndex : mBadIndexChoices) {
            SCOPED_TRACE("Bad Index: " + std::to_string(mBadIndex));
            mBadIndex = kBadIndex;
            if (mBadIndex < 8 &&
                (mSpecificationLevels[mBadIndex] == SpecificationLevel::UNSPECIFIED_RANK ||
                 mSpecificationLevels[mBadIndex] == SpecificationLevel::UNSPECIFIED_TYPE)) {
                continue;
            }
            for (const auto kOperandLocation : mOperandLocationChoices) {
                mOperandLocation = kOperandLocation;
                SCOPED_TRACE("Operand Location: " + toString(mOperandLocation));
                for (const auto kOutputBufferSize : mBufferSizeChoices) {
                    mOutputBufferSize = kOutputBufferSize;
                    SCOPED_TRACE("Output Buffer Size: " + toString(mOutputBufferSize));
                    TestOne<T, TensorType>();
                }
            }
        }
    }

    const UnspecifiedOperand kUnspecifiedOperand = std::get<0>(GetParam());
    const SpecificationLevel kSpecificationLevelModel = std::get<1>(GetParam());
    const SpecificationLevel kSpecificationLevelExecution = std::get<2>(GetParam());

    std::vector<SpecificationLevel> mSpecificationLevels;
    std::vector<Type> mOperandTypes;
    OptionalType mOptionalType = OptionalType::CONST;

    // Iterate all combinations in TestAll()
    std::vector<uint32_t> mBadIndexChoices;
    std::vector<OperandLocation> mOperandLocationChoices;
    std::vector<BufferSize> mBufferSizeChoices = {BufferSize::EQUAL};

    uint32_t mBadIndex;
    OperandLocation mOperandLocation;
    BufferSize mOutputBufferSize;
};

TEST_P(UnspecifiedDimensionsTest, Float32) {
    TestAll<float, Type::TENSOR_FLOAT32>();
}

TEST_P(UnspecifiedDimensionsTest, Quant8) {
    TestAll<uint8_t, Type::TENSOR_QUANT8_ASYMM>();
}

TEST_P(UnspecifiedDimensionsTest, Float16) {
    TestAll<_Float16, Type::TENSOR_FLOAT16>();
}

static const auto kAllSpecificationLevelsModel =
        testing::Values(SpecificationLevel::FULLY_SPECIFIED, SpecificationLevel::UNSPECIFIED_DIM,
                        SpecificationLevel::UNSPECIFIED_RANK);
static const auto kAllSpecificationLevelsExecution =
        testing::Values(SpecificationLevel::FULLY_SPECIFIED, SpecificationLevel::UNSPECIFIED_DIM,
                        SpecificationLevel::UNSPECIFIED_RANK, SpecificationLevel::UNSPECIFIED_TYPE);
static const auto kFullySpecified = testing::Values(SpecificationLevel::FULLY_SPECIFIED);

INSTANTIATE_TEST_CASE_P(ModelInputTest, UnspecifiedDimensionsTest,
                        testing::Combine(testing::Values(UnspecifiedOperand::INPUT_MANDATORY),
                                         kAllSpecificationLevelsModel,
                                         kAllSpecificationLevelsExecution));

INSTANTIATE_TEST_CASE_P(ConstantParameterTest, UnspecifiedDimensionsTest,
                        testing::Combine(testing::Values(UnspecifiedOperand::CONST_MANDATORY),
                                         kAllSpecificationLevelsModel, kFullySpecified));

INSTANTIATE_TEST_CASE_P(TemporaryVariableTest, UnspecifiedDimensionsTest,
                        testing::Combine(testing::Values(UnspecifiedOperand::TEMPORARY_VARIABLE),
                                         kAllSpecificationLevelsModel, kFullySpecified));

INSTANTIATE_TEST_CASE_P(OptionalConstantTest, UnspecifiedDimensionsTest,
                        testing::Combine(testing::Values(UnspecifiedOperand::CONST_OPTIONAL),
                                         kAllSpecificationLevelsModel, kFullySpecified));

INSTANTIATE_TEST_CASE_P(OptionalInputTest, UnspecifiedDimensionsTest,
                        testing::Combine(testing::Values(UnspecifiedOperand::INPUT_OPTIONAL),
                                         kAllSpecificationLevelsModel,
                                         kAllSpecificationLevelsExecution));

INSTANTIATE_TEST_CASE_P(ModelOutputTest, UnspecifiedDimensionsTest,
                        testing::Combine(testing::Values(UnspecifiedOperand::OUTPUT),
                                         kAllSpecificationLevelsModel,
                                         kAllSpecificationLevelsExecution));

}  // end namespace