// Generated from reduce_min.mod.py // DO NOT EDIT // clang-format off #include "TestHarness.h" using namespace test_helper; // NOLINT(google-build-using-namespace) namespace generated_tests::reduce_min { const TestModel& get_test_model() { static TestModel model = { .main = { .operands = {{ // input0 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1.0f, -2.0f, 3.0f, 4.0f, 5.0f, -6.0f}) }, { // param .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // param1 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output0 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2.0f, 3.0f, -6.0f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model = TestModelManager::get().add("reduce_min", get_test_model()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // input0 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // param1 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output0 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2.0f, 3.0f, -6.0f}) }, { // input0_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1.0f, -2.0f, 3.0f, 4.0f, 5.0f, -6.0f}) }, { // placeholder .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param8 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_all_inputs_as_internal = TestModelManager::get().add("reduce_min_all_inputs_as_internal", get_test_model_all_inputs_as_internal()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_relaxed() { static TestModel model = { .main = { .operands = {{ // input0 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1.0f, -2.0f, 3.0f, 4.0f, 5.0f, -6.0f}) }, { // param .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // param1 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output0 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2.0f, 3.0f, -6.0f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_relaxed = TestModelManager::get().add("reduce_min_relaxed", get_test_model_relaxed()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // input0 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // param1 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output0 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2.0f, 3.0f, -6.0f}) }, { // input0_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1.0f, -2.0f, 3.0f, 4.0f, 5.0f, -6.0f}) }, { // placeholder1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param9 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal = TestModelManager::get().add("reduce_min_relaxed_all_inputs_as_internal", get_test_model_relaxed_all_inputs_as_internal()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_float16() { static TestModel model = { .main = { .operands = {{ // input0 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({-1.0f, -2.0f, 3.0f, 4.0f, 5.0f, -6.0f}) }, { // param .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // param1 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output0 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 3.0f, -6.0f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_float16 = TestModelManager::get().add("reduce_min_float16", get_test_model_float16()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // input0 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // param .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // param1 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output0 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({-2.0f, 3.0f, -6.0f}) }, { // input0_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({-1.0f, -2.0f, 3.0f, 4.0f, 5.0f, -6.0f}) }, { // placeholder2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param10 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal = TestModelManager::get().add("reduce_min_float16_all_inputs_as_internal", get_test_model_float16_all_inputs_as_internal()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_quant8() { static TestModel model = { .main = { .operands = {{ // input0 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({125, 123, 133, 135, 137, 115}) }, { // param .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // param1 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output0 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({123, 133, 115}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_quant8 = TestModelManager::get().add("reduce_min_quant8", get_test_model_quant8()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // input0 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // param1 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output0 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({123, 133, 115}) }, { // input0_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({125, 123, 133, 135, 137, 115}) }, { // placeholder3 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127}) }, { // param11 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal = TestModelManager::get().add("reduce_min_quant8_all_inputs_as_internal", get_test_model_quant8_all_inputs_as_internal()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_2() { static TestModel model = { .main = { .operands = {{ // input01 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({9.527f}) }, { // param2 .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // param3 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output01 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({9.527f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_2 = TestModelManager::get().add("reduce_min_2", get_test_model_2()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_all_inputs_as_internal_2() { static TestModel model = { .main = { .operands = {{ // input01 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param2 .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // param3 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output01 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({9.527f}) }, { // input01_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({9.527f}) }, { // placeholder4 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param12 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_all_inputs_as_internal_2 = TestModelManager::get().add("reduce_min_all_inputs_as_internal_2", get_test_model_all_inputs_as_internal_2()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_relaxed_2() { static TestModel model = { .main = { .operands = {{ // input01 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({9.527f}) }, { // param2 .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // param3 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output01 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({9.527f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_relaxed_2 = TestModelManager::get().add("reduce_min_relaxed_2", get_test_model_relaxed_2()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_relaxed_all_inputs_as_internal_2() { static TestModel model = { .main = { .operands = {{ // input01 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param2 .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // param3 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output01 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({9.527f}) }, { // input01_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({9.527f}) }, { // placeholder5 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param13 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("reduce_min_relaxed_all_inputs_as_internal_2", get_test_model_relaxed_all_inputs_as_internal_2()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_float16_2() { static TestModel model = { .main = { .operands = {{ // input01 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({9.527000427246094f}) }, { // param2 .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // param3 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output01 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({9.527000427246094f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_float16_2 = TestModelManager::get().add("reduce_min_float16_2", get_test_model_float16_2()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_float16_all_inputs_as_internal_2() { static TestModel model = { .main = { .operands = {{ // input01 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // param2 .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // param3 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output01 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({9.527000427246094f}) }, { // input01_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({9.527000427246094f}) }, { // placeholder6 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param14 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_2 = TestModelManager::get().add("reduce_min_float16_all_inputs_as_internal_2", get_test_model_float16_all_inputs_as_internal_2()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_quant8_2() { static TestModel model = { .main = { .operands = {{ // input01 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({146}) }, { // param2 .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // param3 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output01 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({146}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_quant8_2 = TestModelManager::get().add("reduce_min_quant8_2", get_test_model_quant8_2()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_quant8_all_inputs_as_internal_2() { static TestModel model = { .main = { .operands = {{ // input01 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param2 .type = TestOperandType::TENSOR_INT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // param3 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output01 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({146}) }, { // input01_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({146}) }, { // placeholder7 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127}) }, { // param15 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("reduce_min_quant8_all_inputs_as_internal_2", get_test_model_quant8_all_inputs_as_internal_2()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_3() { static TestModel model = { .main = { .operands = {{ // input02 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 2.2f, 2.3f, 2.4f}) }, { // param4 .type = TestOperandType::TENSOR_INT32, .dimensions = {4}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1, 0, -3, -3}) }, { // param5 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output02 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_3 = TestModelManager::get().add("reduce_min_3", get_test_model_3()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_all_inputs_as_internal_3() { static TestModel model = { .main = { .operands = {{ // input02 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param4 .type = TestOperandType::TENSOR_INT32, .dimensions = {4}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1, 0, -3, -3}) }, { // param5 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output02 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f}) }, { // input02_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 2.2f, 2.3f, 2.4f}) }, { // placeholder8 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param16 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_all_inputs_as_internal_3 = TestModelManager::get().add("reduce_min_all_inputs_as_internal_3", get_test_model_all_inputs_as_internal_3()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_relaxed_3() { static TestModel model = { .main = { .operands = {{ // input02 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 2.2f, 2.3f, 2.4f}) }, { // param4 .type = TestOperandType::TENSOR_INT32, .dimensions = {4}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1, 0, -3, -3}) }, { // param5 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output02 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_relaxed_3 = TestModelManager::get().add("reduce_min_relaxed_3", get_test_model_relaxed_3()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_relaxed_all_inputs_as_internal_3() { static TestModel model = { .main = { .operands = {{ // input02 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param4 .type = TestOperandType::TENSOR_INT32, .dimensions = {4}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1, 0, -3, -3}) }, { // param5 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output02 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f}) }, { // input02_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 2.2f, 2.3f, 2.4f}) }, { // placeholder9 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param17 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_3 = TestModelManager::get().add("reduce_min_relaxed_all_inputs_as_internal_3", get_test_model_relaxed_all_inputs_as_internal_3()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_float16_3() { static TestModel model = { .main = { .operands = {{ // input02 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f, 0.20000000298023224f, 0.30000001192092896f, 0.4000000059604645f, 0.5f, 0.6000000238418579f, 0.699999988079071f, 0.800000011920929f, 0.8999999761581421f, 1.0f, 1.100000023841858f, 1.2000000476837158f, 1.2999999523162842f, 1.399999976158142f, 1.5f, 1.600000023841858f, 1.7000000476837158f, 1.7999999523162842f, 1.899999976158142f, 2.0f, 2.0999999046325684f, 2.200000047683716f, 2.299999952316284f, 2.4000000953674316f}) }, { // param4 .type = TestOperandType::TENSOR_INT32, .dimensions = {4}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1, 0, -3, -3}) }, { // param5 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output02 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f, 0.20000000298023224f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_float16_3 = TestModelManager::get().add("reduce_min_float16_3", get_test_model_float16_3()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_float16_all_inputs_as_internal_3() { static TestModel model = { .main = { .operands = {{ // input02 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // param4 .type = TestOperandType::TENSOR_INT32, .dimensions = {4}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1, 0, -3, -3}) }, { // param5 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output02 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f, 0.20000000298023224f}) }, { // input02_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f, 0.20000000298023224f, 0.30000001192092896f, 0.4000000059604645f, 0.5f, 0.6000000238418579f, 0.699999988079071f, 0.800000011920929f, 0.8999999761581421f, 1.0f, 1.100000023841858f, 1.2000000476837158f, 1.2999999523162842f, 1.399999976158142f, 1.5f, 1.600000023841858f, 1.7000000476837158f, 1.7999999523162842f, 1.899999976158142f, 2.0f, 2.0999999046325684f, 2.200000047683716f, 2.299999952316284f, 2.4000000953674316f}) }, { // placeholder10 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param18 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_3 = TestModelManager::get().add("reduce_min_float16_all_inputs_as_internal_3", get_test_model_float16_all_inputs_as_internal_3()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_quant8_3() { static TestModel model = { .main = { .operands = {{ // input02 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127, 127, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 130, 130, 130, 130, 130, 131, 131, 131, 131, 131, 132, 132}) }, { // param4 .type = TestOperandType::TENSOR_INT32, .dimensions = {4}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1, 0, -3, -3}) }, { // param5 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output02 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2}, .numberOfConsumers = 0, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127, 127}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_quant8_3 = TestModelManager::get().add("reduce_min_quant8_3", get_test_model_quant8_3()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_quant8_all_inputs_as_internal_3() { static TestModel model = { .main = { .operands = {{ // input02 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param4 .type = TestOperandType::TENSOR_INT32, .dimensions = {4}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1, 0, -3, -3}) }, { // param5 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({false}) }, { // output02 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2}, .numberOfConsumers = 0, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127, 127}) }, { // input02_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127, 127, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 130, 130, 130, 130, 130, 131, 131, 131, 131, 131, 132, 132}) }, { // placeholder11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127}) }, { // param19 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_3 = TestModelManager::get().add("reduce_min_quant8_all_inputs_as_internal_3", get_test_model_quant8_all_inputs_as_internal_3()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_4() { static TestModel model = { .main = { .operands = {{ // input03 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 2.2f, 2.3f, 2.4f}) }, { // param6 .type = TestOperandType::TENSOR_INT32, .dimensions = {2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 2}) }, { // param7 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output03 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1, 3, 1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.3f, 0.5f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_4 = TestModelManager::get().add("reduce_min_4", get_test_model_4()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_all_inputs_as_internal_4() { static TestModel model = { .main = { .operands = {{ // input03 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param6 .type = TestOperandType::TENSOR_INT32, .dimensions = {2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 2}) }, { // param7 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output03 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1, 3, 1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.3f, 0.5f}) }, { // input03_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 2.2f, 2.3f, 2.4f}) }, { // placeholder12 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param20 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_all_inputs_as_internal_4 = TestModelManager::get().add("reduce_min_all_inputs_as_internal_4", get_test_model_all_inputs_as_internal_4()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_relaxed_4() { static TestModel model = { .main = { .operands = {{ // input03 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 2.2f, 2.3f, 2.4f}) }, { // param6 .type = TestOperandType::TENSOR_INT32, .dimensions = {2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 2}) }, { // param7 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output03 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1, 3, 1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.3f, 0.5f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_relaxed_4 = TestModelManager::get().add("reduce_min_relaxed_4", get_test_model_relaxed_4()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_relaxed_all_inputs_as_internal_4() { static TestModel model = { .main = { .operands = {{ // input03 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param6 .type = TestOperandType::TENSOR_INT32, .dimensions = {2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 2}) }, { // param7 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output03 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1, 3, 1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.3f, 0.5f}) }, { // input03_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 2.2f, 2.3f, 2.4f}) }, { // placeholder13 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param21 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_relaxed_all_inputs_as_internal_4 = TestModelManager::get().add("reduce_min_relaxed_all_inputs_as_internal_4", get_test_model_relaxed_all_inputs_as_internal_4()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_float16_4() { static TestModel model = { .main = { .operands = {{ // input03 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f, 0.20000000298023224f, 0.30000001192092896f, 0.4000000059604645f, 0.5f, 0.6000000238418579f, 0.699999988079071f, 0.800000011920929f, 0.8999999761581421f, 1.0f, 1.100000023841858f, 1.2000000476837158f, 1.2999999523162842f, 1.399999976158142f, 1.5f, 1.600000023841858f, 1.7000000476837158f, 1.7999999523162842f, 1.899999976158142f, 2.0f, 2.0999999046325684f, 2.200000047683716f, 2.299999952316284f, 2.4000000953674316f}) }, { // param6 .type = TestOperandType::TENSOR_INT32, .dimensions = {2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 2}) }, { // param7 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output03 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1, 3, 1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f, 0.30000001192092896f, 0.5f}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_float16_4 = TestModelManager::get().add("reduce_min_float16_4", get_test_model_float16_4()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_float16_all_inputs_as_internal_4() { static TestModel model = { .main = { .operands = {{ // input03 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // param6 .type = TestOperandType::TENSOR_INT32, .dimensions = {2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 2}) }, { // param7 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output03 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1, 3, 1}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f, 0.30000001192092896f, 0.5f}) }, { // input03_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f, 0.20000000298023224f, 0.30000001192092896f, 0.4000000059604645f, 0.5f, 0.6000000238418579f, 0.699999988079071f, 0.800000011920929f, 0.8999999761581421f, 1.0f, 1.100000023841858f, 1.2000000476837158f, 1.2999999523162842f, 1.399999976158142f, 1.5f, 1.600000023841858f, 1.7000000476837158f, 1.7999999523162842f, 1.899999976158142f, 2.0f, 2.0999999046325684f, 2.200000047683716f, 2.299999952316284f, 2.4000000953674316f}) }, { // placeholder14 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param22 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_float16_all_inputs_as_internal_4 = TestModelManager::get().add("reduce_min_float16_all_inputs_as_internal_4", get_test_model_float16_all_inputs_as_internal_4()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_quant8_4() { static TestModel model = { .main = { .operands = {{ // input03 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127, 127, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 130, 130, 130, 130, 130, 131, 131, 131, 131, 131, 132, 132}) }, { // param6 .type = TestOperandType::TENSOR_INT32, .dimensions = {2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 2}) }, { // param7 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output03 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 3, 1}, .numberOfConsumers = 0, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127, 128, 128}) }}, .operations = {{ .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {0}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_quant8_4 = TestModelManager::get().add("reduce_min_quant8_4", get_test_model_quant8_4()); } // namespace generated_tests::reduce_min namespace generated_tests::reduce_min { const TestModel& get_test_model_quant8_all_inputs_as_internal_4() { static TestModel model = { .main = { .operands = {{ // input03 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // param6 .type = TestOperandType::TENSOR_INT32, .dimensions = {2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 2}) }, { // param7 .type = TestOperandType::BOOL, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({true}) }, { // output03 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 3, 1}, .numberOfConsumers = 0, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127, 128, 128}) }, { // input03_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {4, 3, 2}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127, 127, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129, 130, 130, 130, 130, 130, 131, 131, 131, 131, 131, 132, 132}) }, { // placeholder15 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.5f, .zeroPoint = 127, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({127}) }, { // param23 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {4, 5, 6}, .outputs = {0} }, { .type = TestOperationType::REDUCE_MIN, .inputs = {0, 1, 2}, .outputs = {3} }}, .inputIndexes = {4}, .outputIndexes = {3} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_quant8_all_inputs_as_internal_4 = TestModelManager::get().add("reduce_min_quant8_all_inputs_as_internal_4", get_test_model_quant8_all_inputs_as_internal_4()); } // namespace generated_tests::reduce_min