// Generated from gather.mod.py // DO NOT EDIT // clang-format off #include "TestHarness.h" using namespace test_helper; namespace generated_tests::gather { const TestModel& get_test_model() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input0 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param1 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output0 .channelQuant = {}, .data = TestBuffer::createFromVector({0.7f, 0.8f, -2.0f, 0.2f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model = TestModelManager::get().add("gather", get_test_model()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_all_inputs_as_internal() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input0 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param1 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output0 .channelQuant = {}, .data = TestBuffer::createFromVector({0.7f, 0.8f, -2.0f, 0.2f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input0_new .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param16 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_all_inputs_as_internal = TestModelManager::get().add("gather_all_inputs_as_internal", get_test_model_all_inputs_as_internal()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {0}, .operands = {{ // input0 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param1 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output0 .channelQuant = {}, .data = TestBuffer::createFromVector({0.7f, 0.8f, -2.0f, 0.2f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed = TestModelManager::get().add("gather_relaxed", get_test_model_relaxed()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_all_inputs_as_internal() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {4}, .operands = {{ // input0 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param1 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output0 .channelQuant = {}, .data = TestBuffer::createFromVector({0.7f, 0.8f, -2.0f, 0.2f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input0_new .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder1 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param17 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal = TestModelManager::get().add("gather_relaxed_all_inputs_as_internal", get_test_model_relaxed_all_inputs_as_internal()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input0 .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param1 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output0 .channelQuant = {}, .data = TestBuffer::createFromVector({128, 129, 123, 127}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8 = TestModelManager::get().add("gather_quant8", get_test_model_quant8()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_all_inputs_as_internal() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input0 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param1 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output0 .channelQuant = {}, .data = TestBuffer::createFromVector({128, 129, 123, 127}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // input0_new .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // placeholder2 .channelQuant = {}, .data = TestBuffer::createFromVector({127}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param18 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal = TestModelManager::get().add("gather_quant8_all_inputs_as_internal", get_test_model_quant8_all_inputs_as_internal()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_int32() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input0 .channelQuant = {}, .data = TestBuffer::createFromVector({-2, 0, 1, 1}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // param .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param1 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output0 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 1, -2, 0}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_int32 = TestModelManager::get().add("gather_int32", get_test_model_int32()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input0 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param1 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output0 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.699999988079071f, 0.800000011920929f, -2.0f, 0.20000000298023224f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16 = TestModelManager::get().add("gather_float16", get_test_model_float16()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_all_inputs_as_internal() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input0 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param1 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output0 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.699999988079071f, 0.800000011920929f, -2.0f, 0.20000000298023224f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // input0_new .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // placeholder3 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param19 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal = TestModelManager::get().add("gather_float16_all_inputs_as_internal", get_test_model_float16_all_inputs_as_internal()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_2() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input01 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param2 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param3 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output01 .channelQuant = {}, .data = TestBuffer::createFromVector({0.7f, 0.8f}), .dimensions = {1, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_2 = TestModelManager::get().add("gather_2", get_test_model_2()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_all_inputs_as_internal_2() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input01 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param2 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param3 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output01 .channelQuant = {}, .data = TestBuffer::createFromVector({0.7f, 0.8f}), .dimensions = {1, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input01_new .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder4 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param20 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_all_inputs_as_internal_2 = TestModelManager::get().add("gather_all_inputs_as_internal_2", get_test_model_all_inputs_as_internal_2()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_2() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {0}, .operands = {{ // input01 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param2 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param3 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output01 .channelQuant = {}, .data = TestBuffer::createFromVector({0.7f, 0.8f}), .dimensions = {1, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_2 = TestModelManager::get().add("gather_relaxed_2", get_test_model_relaxed_2()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_all_inputs_as_internal_2() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {4}, .operands = {{ // input01 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param2 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param3 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output01 .channelQuant = {}, .data = TestBuffer::createFromVector({0.7f, 0.8f}), .dimensions = {1, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input01_new .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder5 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param21 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("gather_relaxed_all_inputs_as_internal_2", get_test_model_relaxed_all_inputs_as_internal_2()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_2() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input01 .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param2 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param3 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output01 .channelQuant = {}, .data = TestBuffer::createFromVector({128, 129}), .dimensions = {1, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_2 = TestModelManager::get().add("gather_quant8_2", get_test_model_quant8_2()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_all_inputs_as_internal_2() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input01 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param2 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param3 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output01 .channelQuant = {}, .data = TestBuffer::createFromVector({128, 129}), .dimensions = {1, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // input01_new .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // placeholder6 .channelQuant = {}, .data = TestBuffer::createFromVector({127}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param22 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("gather_quant8_all_inputs_as_internal_2", get_test_model_quant8_all_inputs_as_internal_2()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_int32_2() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input01 .channelQuant = {}, .data = TestBuffer::createFromVector({-2, 0, 1, 1}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // param2 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param3 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output01 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 1}), .dimensions = {1, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_int32_2 = TestModelManager::get().add("gather_int32_2", get_test_model_int32_2()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_2() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input01 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param2 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param3 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output01 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.699999988079071f, 0.800000011920929f}), .dimensions = {1, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_2 = TestModelManager::get().add("gather_float16_2", get_test_model_float16_2()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_all_inputs_as_internal_2() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input01 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param2 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param3 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output01 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.699999988079071f, 0.800000011920929f}), .dimensions = {1, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // input01_new .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // placeholder7 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param23 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_2 = TestModelManager::get().add("gather_float16_all_inputs_as_internal_2", get_test_model_float16_all_inputs_as_internal_2()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_3() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input02 .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param4 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param5 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output02 .channelQuant = {}, .data = TestBuffer::createFromVector({2.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_3 = TestModelManager::get().add("gather_3", get_test_model_3()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_all_inputs_as_internal_3() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input02 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param4 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param5 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output02 .channelQuant = {}, .data = TestBuffer::createFromVector({2.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input02_new .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder8 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param24 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_all_inputs_as_internal_3 = TestModelManager::get().add("gather_all_inputs_as_internal_3", get_test_model_all_inputs_as_internal_3()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_3() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {0}, .operands = {{ // input02 .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param4 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param5 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output02 .channelQuant = {}, .data = TestBuffer::createFromVector({2.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_3 = TestModelManager::get().add("gather_relaxed_3", get_test_model_relaxed_3()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_all_inputs_as_internal_3() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {4}, .operands = {{ // input02 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param4 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param5 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output02 .channelQuant = {}, .data = TestBuffer::createFromVector({2.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input02_new .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder9 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param25 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_3 = TestModelManager::get().add("gather_relaxed_all_inputs_as_internal_3", get_test_model_relaxed_all_inputs_as_internal_3()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_3() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input02 .channelQuant = {}, .data = TestBuffer::createFromVector({129, 131, 133}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param4 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param5 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output02 .channelQuant = {}, .data = TestBuffer::createFromVector({131}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_3 = TestModelManager::get().add("gather_quant8_3", get_test_model_quant8_3()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_all_inputs_as_internal_3() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input02 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param4 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param5 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output02 .channelQuant = {}, .data = TestBuffer::createFromVector({131}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // input02_new .channelQuant = {}, .data = TestBuffer::createFromVector({129, 131, 133}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // placeholder10 .channelQuant = {}, .data = TestBuffer::createFromVector({127}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param26 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_3 = TestModelManager::get().add("gather_quant8_all_inputs_as_internal_3", get_test_model_quant8_all_inputs_as_internal_3()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_int32_3() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input02 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 2, 3}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // param4 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param5 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output02 .channelQuant = {}, .data = TestBuffer::createFromVector({2}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_int32_3 = TestModelManager::get().add("gather_int32_3", get_test_model_int32_3()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_3() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input02 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param4 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param5 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output02 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({2.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_3 = TestModelManager::get().add("gather_float16_3", get_test_model_float16_3()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_all_inputs_as_internal_3() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input02 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param4 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param5 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output02 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({2.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // input02_new .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // placeholder11 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param27 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_3 = TestModelManager::get().add("gather_float16_all_inputs_as_internal_3", get_test_model_float16_all_inputs_as_internal_3()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_4() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input03 .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param6 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param7 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output03 .channelQuant = {}, .data = TestBuffer::createFromVector({2.0f, 1.0f}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_4 = TestModelManager::get().add("gather_4", get_test_model_4()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_all_inputs_as_internal_4() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input03 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param6 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param7 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output03 .channelQuant = {}, .data = TestBuffer::createFromVector({2.0f, 1.0f}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input03_new .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder12 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param28 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_all_inputs_as_internal_4 = TestModelManager::get().add("gather_all_inputs_as_internal_4", get_test_model_all_inputs_as_internal_4()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_4() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {0}, .operands = {{ // input03 .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param6 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param7 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output03 .channelQuant = {}, .data = TestBuffer::createFromVector({2.0f, 1.0f}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_4 = TestModelManager::get().add("gather_relaxed_4", get_test_model_relaxed_4()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_all_inputs_as_internal_4() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {4}, .operands = {{ // input03 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param6 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param7 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output03 .channelQuant = {}, .data = TestBuffer::createFromVector({2.0f, 1.0f}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input03_new .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder13 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param29 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_4 = TestModelManager::get().add("gather_relaxed_all_inputs_as_internal_4", get_test_model_relaxed_all_inputs_as_internal_4()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_4() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input03 .channelQuant = {}, .data = TestBuffer::createFromVector({129, 131, 133}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param6 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param7 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output03 .channelQuant = {}, .data = TestBuffer::createFromVector({131, 129}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_4 = TestModelManager::get().add("gather_quant8_4", get_test_model_quant8_4()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_all_inputs_as_internal_4() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input03 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param6 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param7 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output03 .channelQuant = {}, .data = TestBuffer::createFromVector({131, 129}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // input03_new .channelQuant = {}, .data = TestBuffer::createFromVector({129, 131, 133}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // placeholder14 .channelQuant = {}, .data = TestBuffer::createFromVector({127}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param30 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_4 = TestModelManager::get().add("gather_quant8_all_inputs_as_internal_4", get_test_model_quant8_all_inputs_as_internal_4()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_int32_4() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input03 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 2, 3}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // param6 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param7 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output03 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 1}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_int32_4 = TestModelManager::get().add("gather_int32_4", get_test_model_int32_4()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_4() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input03 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param6 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param7 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output03 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({2.0f, 1.0f}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_4 = TestModelManager::get().add("gather_float16_4", get_test_model_float16_4()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_all_inputs_as_internal_4() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input03 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param6 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param7 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output03 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({2.0f, 1.0f}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // input03_new .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f}), .dimensions = {3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // placeholder15 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param31 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_4 = TestModelManager::get().add("gather_float16_all_inputs_as_internal_4", get_test_model_float16_all_inputs_as_internal_4()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_5() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input04 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param8 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param9 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output04 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f, -2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_5 = TestModelManager::get().add("gather_5", get_test_model_5()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_all_inputs_as_internal_5() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input04 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param8 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param9 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output04 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f, -2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input04_new .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder16 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param32 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_all_inputs_as_internal_5 = TestModelManager::get().add("gather_all_inputs_as_internal_5", get_test_model_all_inputs_as_internal_5()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_5() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {0}, .operands = {{ // input04 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param8 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param9 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output04 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f, -2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_5 = TestModelManager::get().add("gather_relaxed_5", get_test_model_relaxed_5()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_all_inputs_as_internal_5() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {4}, .operands = {{ // input04 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param8 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param9 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output04 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f, -2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {2, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input04_new .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder17 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param33 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_5 = TestModelManager::get().add("gather_relaxed_all_inputs_as_internal_5", get_test_model_relaxed_all_inputs_as_internal_5()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_5() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input04 .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param8 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param9 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output04 .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129, 123, 127, 128, 129}), .dimensions = {2, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_5 = TestModelManager::get().add("gather_quant8_5", get_test_model_quant8_5()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_all_inputs_as_internal_5() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input04 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param8 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param9 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output04 .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129, 123, 127, 128, 129}), .dimensions = {2, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // input04_new .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // placeholder18 .channelQuant = {}, .data = TestBuffer::createFromVector({127}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param34 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_5 = TestModelManager::get().add("gather_quant8_all_inputs_as_internal_5", get_test_model_quant8_all_inputs_as_internal_5()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_int32_5() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input04 .channelQuant = {}, .data = TestBuffer::createFromVector({-2, 0, 1, 1}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // param8 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param9 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output04 .channelQuant = {}, .data = TestBuffer::createFromVector({-2, 0, 1, 1, -2, 0, 1, 1}), .dimensions = {2, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_int32_5 = TestModelManager::get().add("gather_int32_5", get_test_model_int32_5()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_5() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input04 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param8 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param9 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output04 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f, -2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {2, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_5 = TestModelManager::get().add("gather_float16_5", get_test_model_float16_5()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_all_inputs_as_internal_5() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input04 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param8 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param9 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output04 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f, -2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {2, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // input04_new .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // placeholder19 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param35 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_5 = TestModelManager::get().add("gather_float16_all_inputs_as_internal_5", get_test_model_float16_all_inputs_as_internal_5()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_6() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input05 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param10 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param11 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 3}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output05 .channelQuant = {}, .data = TestBuffer::createFromVector({0.2f, 0.8f}), .dimensions = {2, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_6 = TestModelManager::get().add("gather_6", get_test_model_6()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_all_inputs_as_internal_6() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input05 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param10 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param11 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 3}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output05 .channelQuant = {}, .data = TestBuffer::createFromVector({0.2f, 0.8f}), .dimensions = {2, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input05_new .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder20 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param36 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_all_inputs_as_internal_6 = TestModelManager::get().add("gather_all_inputs_as_internal_6", get_test_model_all_inputs_as_internal_6()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_6() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {0}, .operands = {{ // input05 .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param10 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param11 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 3}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output05 .channelQuant = {}, .data = TestBuffer::createFromVector({0.2f, 0.8f}), .dimensions = {2, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_6 = TestModelManager::get().add("gather_relaxed_6", get_test_model_relaxed_6()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_all_inputs_as_internal_6() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {4}, .operands = {{ // input05 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param10 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param11 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 3}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output05 .channelQuant = {}, .data = TestBuffer::createFromVector({0.2f, 0.8f}), .dimensions = {2, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input05_new .channelQuant = {}, .data = TestBuffer::createFromVector({-2.0f, 0.2f, 0.7f, 0.8f}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder21 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param37 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_6 = TestModelManager::get().add("gather_relaxed_all_inputs_as_internal_6", get_test_model_relaxed_all_inputs_as_internal_6()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_6() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input05 .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param10 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param11 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 3}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output05 .channelQuant = {}, .data = TestBuffer::createFromVector({127, 129}), .dimensions = {2, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_6 = TestModelManager::get().add("gather_quant8_6", get_test_model_quant8_6()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_all_inputs_as_internal_6() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input05 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param10 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param11 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 3}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output05 .channelQuant = {}, .data = TestBuffer::createFromVector({127, 129}), .dimensions = {2, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // input05_new .channelQuant = {}, .data = TestBuffer::createFromVector({123, 127, 128, 129}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // placeholder22 .channelQuant = {}, .data = TestBuffer::createFromVector({127}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param38 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_6 = TestModelManager::get().add("gather_quant8_all_inputs_as_internal_6", get_test_model_quant8_all_inputs_as_internal_6()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_int32_6() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input05 .channelQuant = {}, .data = TestBuffer::createFromVector({-2, 0, 1, 1}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // param10 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param11 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 3}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output05 .channelQuant = {}, .data = TestBuffer::createFromVector({0, 1}), .dimensions = {2, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_int32_6 = TestModelManager::get().add("gather_int32_6", get_test_model_int32_6()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_6() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input05 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param10 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param11 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 3}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output05 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.800000011920929f}), .dimensions = {2, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_6 = TestModelManager::get().add("gather_float16_6", get_test_model_float16_6()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_all_inputs_as_internal_6() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input05 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param10 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param11 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 3}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output05 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.800000011920929f}), .dimensions = {2, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // input05_new .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 0.20000000298023224f, 0.699999988079071f, 0.800000011920929f}), .dimensions = {4, 1}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // placeholder23 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param39 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_6 = TestModelManager::get().add("gather_float16_all_inputs_as_internal_6", get_test_model_float16_all_inputs_as_internal_6()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_7() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input06 .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param12 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param13 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output06 .channelQuant = {}, .data = TestBuffer::createFromVector({4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_7 = TestModelManager::get().add("gather_7", get_test_model_7()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_all_inputs_as_internal_7() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input06 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param12 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param13 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output06 .channelQuant = {}, .data = TestBuffer::createFromVector({4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input06_new .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder24 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param40 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_all_inputs_as_internal_7 = TestModelManager::get().add("gather_all_inputs_as_internal_7", get_test_model_all_inputs_as_internal_7()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_7() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {0}, .operands = {{ // input06 .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param12 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param13 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output06 .channelQuant = {}, .data = TestBuffer::createFromVector({4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_7 = TestModelManager::get().add("gather_relaxed_7", get_test_model_relaxed_7()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_all_inputs_as_internal_7() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {4}, .operands = {{ // input06 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param12 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param13 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output06 .channelQuant = {}, .data = TestBuffer::createFromVector({4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input06_new .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder25 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param41 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_7 = TestModelManager::get().add("gather_relaxed_all_inputs_as_internal_7", get_test_model_relaxed_all_inputs_as_internal_7()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_7() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input06 .channelQuant = {}, .data = TestBuffer::createFromVector({129, 131, 133, 135, 137, 139}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param12 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param13 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output06 .channelQuant = {}, .data = TestBuffer::createFromVector({135, 137, 139, 129, 131, 133}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_7 = TestModelManager::get().add("gather_quant8_7", get_test_model_quant8_7()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_all_inputs_as_internal_7() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input06 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param12 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param13 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output06 .channelQuant = {}, .data = TestBuffer::createFromVector({135, 137, 139, 129, 131, 133}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // input06_new .channelQuant = {}, .data = TestBuffer::createFromVector({129, 131, 133, 135, 137, 139}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // placeholder26 .channelQuant = {}, .data = TestBuffer::createFromVector({127}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param42 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_7 = TestModelManager::get().add("gather_quant8_all_inputs_as_internal_7", get_test_model_quant8_all_inputs_as_internal_7()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_int32_7() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input06 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 2, 3, 4, 5, 6}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // param12 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param13 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output06 .channelQuant = {}, .data = TestBuffer::createFromVector({4, 5, 6, 1, 2, 3}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_int32_7 = TestModelManager::get().add("gather_int32_7", get_test_model_int32_7()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_7() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input06 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param12 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param13 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output06 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_7 = TestModelManager::get().add("gather_float16_7", get_test_model_float16_7()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_all_inputs_as_internal_7() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input06 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param12 .channelQuant = {}, .data = TestBuffer::createFromVector({1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param13 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output06 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // input06_new .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // placeholder27 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param43 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_7 = TestModelManager::get().add("gather_float16_all_inputs_as_internal_7", get_test_model_float16_all_inputs_as_internal_7()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input07 .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param14 .channelQuant = {}, .data = TestBuffer::createFromVector({-1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param15 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output07 .channelQuant = {}, .data = TestBuffer::createFromVector({3.0f, 1.0f, 6.0f, 4.0f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_8 = TestModelManager::get().add("gather_8", get_test_model_8()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_all_inputs_as_internal_8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input07 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param14 .channelQuant = {}, .data = TestBuffer::createFromVector({-1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param15 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output07 .channelQuant = {}, .data = TestBuffer::createFromVector({3.0f, 1.0f, 6.0f, 4.0f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input07_new .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder28 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param44 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_all_inputs_as_internal_8 = TestModelManager::get().add("gather_all_inputs_as_internal_8", get_test_model_all_inputs_as_internal_8()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {0}, .operands = {{ // input07 .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param14 .channelQuant = {}, .data = TestBuffer::createFromVector({-1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param15 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output07 .channelQuant = {}, .data = TestBuffer::createFromVector({3.0f, 1.0f, 6.0f, 4.0f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_8 = TestModelManager::get().add("gather_relaxed_8", get_test_model_relaxed_8()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_relaxed_all_inputs_as_internal_8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = true, .main = { .inputIndexes = {4}, .operands = {{ // input07 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param14 .channelQuant = {}, .data = TestBuffer::createFromVector({-1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param15 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output07 .channelQuant = {}, .data = TestBuffer::createFromVector({3.0f, 1.0f, 6.0f, 4.0f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // input07_new .channelQuant = {}, .data = TestBuffer::createFromVector({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // placeholder29 .channelQuant = {}, .data = TestBuffer::createFromVector({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT32, .zeroPoint = 0 }, { // param45 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::UNKNOWN, .referenced = {} }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_8 = TestModelManager::get().add("gather_relaxed_all_inputs_as_internal_8", get_test_model_relaxed_all_inputs_as_internal_8()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input07 .channelQuant = {}, .data = TestBuffer::createFromVector({129, 131, 133, 135, 137, 139}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param14 .channelQuant = {}, .data = TestBuffer::createFromVector({-1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param15 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output07 .channelQuant = {}, .data = TestBuffer::createFromVector({133, 129, 139, 135}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_8 = TestModelManager::get().add("gather_quant8_8", get_test_model_quant8_8()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_quant8_all_inputs_as_internal_8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input07 .channelQuant = {}, .data = TestBuffer::createFromVector({}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param14 .channelQuant = {}, .data = TestBuffer::createFromVector({-1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param15 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output07 .channelQuant = {}, .data = TestBuffer::createFromVector({133, 129, 139, 135}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // input07_new .channelQuant = {}, .data = TestBuffer::createFromVector({129, 131, 133, 135, 137, 139}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // placeholder30 .channelQuant = {}, .data = TestBuffer::createFromVector({127}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.5f, .type = TestOperandType::TENSOR_QUANT8_ASYMM, .zeroPoint = 127 }, { // param46 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_8 = TestModelManager::get().add("gather_quant8_all_inputs_as_internal_8", get_test_model_quant8_all_inputs_as_internal_8()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_int32_8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input07 .channelQuant = {}, .data = TestBuffer::createFromVector({1, 2, 3, 4, 5, 6}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // param14 .channelQuant = {}, .data = TestBuffer::createFromVector({-1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param15 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output07 .channelQuant = {}, .data = TestBuffer::createFromVector({3, 1, 6, 4}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_int32_8 = TestModelManager::get().add("gather_int32_8", get_test_model_int32_8()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {0}, .operands = {{ // input07 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param14 .channelQuant = {}, .data = TestBuffer::createFromVector({-1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param15 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output07 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({3.0f, 1.0f, 6.0f, 4.0f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }}, .operations = {{ .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_8 = TestModelManager::get().add("gather_float16_8", get_test_model_float16_8()); } // namespace generated_tests::gather namespace generated_tests::gather { const TestModel& get_test_model_float16_all_inputs_as_internal_8() { static TestModel model = { .expectFailure = false, .expectedMultinomialDistributionTolerance = 0, .isRelaxed = false, .main = { .inputIndexes = {4}, .operands = {{ // input07 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param14 .channelQuant = {}, .data = TestBuffer::createFromVector({-1}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }, { // param15 .channelQuant = {}, .data = TestBuffer::createFromVector({2, 0}), .dimensions = {2}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_INT32, .zeroPoint = 0 }, { // output07 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({3.0f, 1.0f, 6.0f, 4.0f}), .dimensions = {1, 2, 2}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .numberOfConsumers = 0, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // input07_new .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}), .dimensions = {1, 2, 3}, .isIgnored = false, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // placeholder31 .channelQuant = {}, .data = TestBuffer::createFromVector<_Float16>({0.0f}), .dimensions = {1}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::TENSOR_FLOAT16, .zeroPoint = 0 }, { // param47 .channelQuant = {}, .data = TestBuffer::createFromVector({0}), .dimensions = {}, .isIgnored = false, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .numberOfConsumers = 1, .scale = 0.0f, .type = TestOperandType::INT32, .zeroPoint = 0 }}, .operations = {{ .inputs = {4, 5, 6}, .outputs = {0}, .type = TestOperationType::ADD }, { .inputs = {0, 1, 2}, .outputs = {3}, .type = TestOperationType::GATHER }}, .outputIndexes = {3} }, .minSupportedVersion = TestHalVersion::V1_2, .referenced = {} }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_8 = TestModelManager::get().add("gather_float16_all_inputs_as_internal_8", get_test_model_float16_all_inputs_as_internal_8()); } // namespace generated_tests::gather