diff --git a/src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/exec_net_base.cpp b/src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/exec_net_base.cpp index 114ca088ccb366..4564eb01a44690 100644 --- a/src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/exec_net_base.cpp +++ b/src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/exec_net_base.cpp @@ -4,20 +4,29 @@ #include "behavior/compiled_model/compiled_model_base.hpp" -using namespace ov::test::behavior; -namespace { -auto autoBatchConfigs = []() { - return std::vector{ - // explicit batch size 4 to avoid fallback to no auto-batching - {{ov::device::priorities.name(), std::string(ov::test::utils::DEVICE_TEMPLATE) + "(4)"}, - // no timeout to avoid increasing the test time - {ov::auto_batch_timeout.name(), "0"}}}; -}; +namespace ov { +namespace test { +namespace behavior { +auto autoBatchConfigs = + std::vector{// explicit batch size 4 to avoid fallback to no auto-batching + {{ov::device::priorities.name(), std::string(ov::test::utils::DEVICE_TEMPLATE) + "(4)"}, + // no timeout to avoid increasing the test time + {ov::auto_batch_timeout.name(), "0"}}}; -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVCompiledModelBaseTest, - ::testing::Combine( - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(autoBatchConfigs())), +INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, + OVCompiledModelBaseTest, + ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_BATCH), + ::testing::ValuesIn(autoBatchConfigs)), OVCompiledModelBaseTest::getTestCaseName); -} // namespace +std::vector convert_types = {ov::element::f16, ov::element::i64}; + +INSTANTIATE_TEST_SUITE_P(smoke_AutoBatchBehaviorTests, + CompiledModelSetType, + ::testing::Combine(::testing::ValuesIn(convert_types), + ::testing::Values(ov::test::utils::DEVICE_BATCH), + ::testing::ValuesIn(autoBatchConfigs)), + CompiledModelSetType::getTestCaseName); +} // namespace behavior +} // namespace test +} // namespace ov diff --git a/src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/properties.cpp b/src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/properties.cpp index cac4c929f3f552..2e22e7766c87ff 100644 --- a/src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/properties.cpp +++ b/src/plugins/auto_batch/tests/functional/behavior/ov_executable_network/properties.cpp @@ -1,12 +1,13 @@ // Copyright (C) 2018-2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // - #include "behavior/compiled_model/properties.hpp" -using namespace ov::test::behavior; +#include "behavior/ov_plugin/properties_tests.hpp" -namespace { +namespace ov { +namespace test { +namespace behavior { const std::vector auto_batch_inproperties = { {ov::num_streams(-100)}, @@ -33,4 +34,28 @@ INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, ::testing::ValuesIn(auto_batch_properties)), OVClassCompiledModelPropertiesTests::getTestCaseName); -} // namespace +INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetPropertyTest, + OVClassCompiledModelGetPropertyTest, + ::testing::Values("BATCH:GPU")); + +INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetIncorrectPropertyTest, + OVClassCompiledModelGetIncorrectPropertyTest, + ::testing::Values("BATCH:GPU")); + +const std::vector batchCorrectConfigs = {{}}; + +INSTANTIATE_TEST_SUITE_P(nightly_Auto_Batch_OVClassCompileModelWithCorrectPropertiesAutoBatchingTest, + OVClassCompileModelWithCorrectPropertiesTest, + ::testing::Combine(::testing::Values("BATCH:GPU"), ::testing::ValuesIn(batchCorrectConfigs))); + +const std::vector>> GetMetricTest_ExecutionDevice_GPU = { + {"BATCH:GPU", std::make_pair(ov::AnyMap{}, "GPU.0")}}; + +INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetPropertyTest, + OVClassCompiledModelGetPropertyTest_EXEC_DEVICES, + ::testing::ValuesIn(GetMetricTest_ExecutionDevice_GPU)); + +INSTANTIATE_TEST_SUITE_P(nightly_HeteroAutoBatchOVGetMetricPropsTest, OVGetMetricPropsTest, ::testing::Values("BATCH")); +} // namespace behavior +} // namespace test +} // namespace ov diff --git a/src/plugins/hetero/tests/functional/CMakeLists.txt b/src/plugins/hetero/tests/functional/CMakeLists.txt index 7fc9588b928a41..0180cfc0bc7f35 100644 --- a/src/plugins/hetero/tests/functional/CMakeLists.txt +++ b/src/plugins/hetero/tests/functional/CMakeLists.txt @@ -20,7 +20,7 @@ ov_add_test_target( $/src ADD_CLANG_FORMAT LABELS - OV UNIT HETERO + OV HETERO ) target_compile_definitions(${TARGET_NAME} PRIVATE CI_BUILD_NUMBER=\"mock_version\") diff --git a/src/plugins/hetero/tests/functional/compile_model_tests.cpp b/src/plugins/hetero/tests/functional/compile_model_tests.cpp index c8350f64165c75..87bf99a7272228 100644 --- a/src/plugins/hetero/tests/functional/compile_model_tests.cpp +++ b/src/plugins/hetero/tests/functional/compile_model_tests.cpp @@ -1,6 +1,7 @@ // Copyright (C) 2018-2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // +#include "common_test_utils/test_constants.hpp" #include "hetero_tests.hpp" #include "openvino/runtime/exec_model_info.hpp" #include "openvino/runtime/internal_properties.hpp" @@ -23,37 +24,37 @@ TEST_F(HeteroTests, get_available_devices) { TEST_F(HeteroTests, compile_with_registered_devices) { // Change device priority - core.set_property("HETERO", ov::device::priorities("MOCK0,MOCK1")); + core.set_property(ov::test::utils::DEVICE_HETERO, ov::device::priorities("MOCK0,MOCK1")); auto model = create_model_with_reshape(); - EXPECT_NO_THROW(core.compile_model(model, "HETERO")); + EXPECT_NO_THROW(core.compile_model(model, ov::test::utils::DEVICE_HETERO)); } TEST_F(HeteroTests, compile_with_unregistered_devices_throw) { // Change device priority - core.set_property("HETERO", ov::device::priorities("MOCK2,MOCK3")); + core.set_property(ov::test::utils::DEVICE_HETERO, ov::device::priorities("MOCK2,MOCK3")); auto model = create_model_with_reshape(); - EXPECT_THROW(core.compile_model(model, "HETERO"), ov::Exception); + EXPECT_THROW(core.compile_model(model, ov::test::utils::DEVICE_HETERO), ov::Exception); } TEST_F(HeteroTests, compile_without_device_priorities_throw) { // Change device priority - core.set_property("HETERO", ov::device::priorities("")); + core.set_property(ov::test::utils::DEVICE_HETERO, ov::device::priorities("")); auto model = create_model_with_reshape(); - EXPECT_THROW(core.compile_model(model, "HETERO"), ov::Exception); + EXPECT_THROW(core.compile_model(model, ov::test::utils::DEVICE_HETERO), ov::Exception); } TEST_F(HeteroTests, compile_dynamic_model_fail) { // Change device priority - core.set_property("HETERO", ov::device::priorities("MOCK0,MOCK1")); + core.set_property(ov::test::utils::DEVICE_HETERO, ov::device::priorities("MOCK0,MOCK1")); auto model = create_model_with_subtract_reshape(true); - EXPECT_THROW(core.compile_model(model, "HETERO"), ov::Exception); + EXPECT_THROW(core.compile_model(model, ov::test::utils::DEVICE_HETERO), ov::Exception); } TEST_F(HeteroTests, compile_model_shapeof) { // Change device priority - core.set_property("HETERO", ov::device::priorities("MOCK0,MOCK1")); + core.set_property(ov::test::utils::DEVICE_HETERO, ov::device::priorities("MOCK0,MOCK1")); auto model = create_model_with_subtract_shapeof_reshape(); - EXPECT_NO_THROW(core.compile_model(model, "HETERO")); + EXPECT_NO_THROW(core.compile_model(model, ov::test::utils::DEVICE_HETERO)); } TEST_F(HeteroTests, compile_with_device_properties) { @@ -61,7 +62,7 @@ TEST_F(HeteroTests, compile_with_device_properties) { ov::device::properties("MOCK0", ov::num_streams(4), ov::enable_profiling(false)), ov::device::properties("MOCK1", ov::num_streams(6), ov::enable_profiling(true))}; auto model = create_model_with_subtract_reshape(); - auto compiled_model = core.compile_model(model, "HETERO", config); + auto compiled_model = core.compile_model(model, ov::test::utils::DEVICE_HETERO, config); EXPECT_THROW(compiled_model.get_property(ov::num_streams), ov::Exception); EXPECT_THROW(compiled_model.get_property(ov::enable_profiling), ov::Exception); auto device_properties = compiled_model.get_property(ov::device::properties.name()).as(); @@ -85,7 +86,7 @@ TEST_F(HeteroTests, compile_with_device_properties_no_exclusive) { ov::device::properties("MOCK0", ov::num_streams(4)), ov::device::properties("MOCK1", ov::num_streams(6))}; auto model = create_model_with_subtract_reshape(); - auto compiled_model = core.compile_model(model, "HETERO", config); + auto compiled_model = core.compile_model(model, ov::test::utils::DEVICE_HETERO, config); EXPECT_THROW(compiled_model.get_property(ov::num_streams), ov::Exception); auto device_properties = compiled_model.get_property(ov::device::properties.name()).as(); ASSERT_TRUE(device_properties.count("MOCK0.0")); @@ -105,7 +106,7 @@ TEST_F(HeteroTests, get_runtime_model) { for (auto& op : model->get_ordered_ops()) { original_names.insert(op->get_friendly_name()); } - auto compiled_model = core.compile_model(model, "HETERO", config); + auto compiled_model = core.compile_model(model, ov::test::utils::DEVICE_HETERO, config); auto runtime_model = compiled_model.get_runtime_model(); for (auto& op : runtime_model->get_ordered_ops()) { auto& info = op->get_rt_info(); diff --git a/src/plugins/hetero/tests/functional/import_model_tests.cpp b/src/plugins/hetero/tests/functional/import_model_tests.cpp index d7f6c37308b8a1..1a4cc3073a55db 100644 --- a/src/plugins/hetero/tests/functional/import_model_tests.cpp +++ b/src/plugins/hetero/tests/functional/import_model_tests.cpp @@ -2,9 +2,12 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "common_test_utils/test_constants.hpp" #include "hetero_tests.hpp" -using namespace ov::hetero::tests; +namespace ov { +namespace hetero { +namespace tests { // IR frontend is needed for import #ifdef IR_FRONTEND_ENABLED @@ -12,10 +15,11 @@ TEST_F(HeteroTests, import_single_plugins) { std::stringstream model_stream; auto model = create_model_with_reshape(); { - auto compiled_model = core.compile_model(model, "HETERO", ov::device::priorities("MOCK0")); + auto compiled_model = + core.compile_model(model, ov::test::utils::DEVICE_HETERO, ov::device::priorities("MOCK0")); compiled_model.export_model(model_stream); } - auto compiled_model = core.import_model(model_stream, "HETERO", {}); + auto compiled_model = core.import_model(model_stream, ov::test::utils::DEVICE_HETERO, {}); EXPECT_EQ(1, compiled_model.inputs().size()); EXPECT_EQ(1, compiled_model.outputs().size()); auto infer_request = compiled_model.create_infer_request(); @@ -32,10 +36,11 @@ TEST_F(HeteroTests, import_several_plugins) { std::stringstream model_stream; auto model = create_model_with_subtract(); { - auto compiled_model = core.compile_model(model, "HETERO", ov::device::priorities("MOCK0,MOCK1")); + auto compiled_model = + core.compile_model(model, ov::test::utils::DEVICE_HETERO, ov::device::priorities("MOCK0,MOCK1")); compiled_model.export_model(model_stream); } - auto compiled_model = core.import_model(model_stream, "HETERO", {}); + auto compiled_model = core.import_model(model_stream, ov::test::utils::DEVICE_HETERO, {}); EXPECT_EQ(1, compiled_model.inputs().size()); EXPECT_EQ(1, compiled_model.outputs().size()); auto infer_request = compiled_model.create_infer_request(); @@ -49,3 +54,6 @@ TEST_F(HeteroTests, import_several_plugins) { EXPECT_EQ(memcmp(input_tensor.data(), output_tensor.data(), input_tensor.get_byte_size()), 0); } #endif +} // namespace tests +} // namespace hetero +} // namespace ov \ No newline at end of file diff --git a/src/plugins/hetero/tests/functional/properties_tests.cpp b/src/plugins/hetero/tests/functional/properties_tests.cpp index c71f5597df2e35..cb1a3e6235ff27 100644 --- a/src/plugins/hetero/tests/functional/properties_tests.cpp +++ b/src/plugins/hetero/tests/functional/properties_tests.cpp @@ -1,11 +1,14 @@ // Copyright (C) 2018-2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // +#include "common_test_utils/test_constants.hpp" #include "hetero_tests.hpp" #include "openvino/runtime/internal_properties.hpp" #include "properties.hpp" -using namespace ov::hetero::tests; +namespace ov { +namespace hetero { +namespace tests { TEST_F(HeteroTests, get_property_supported_properties) { const std::vector supported_properties = {ov::supported_properties, @@ -13,7 +16,7 @@ TEST_F(HeteroTests, get_property_supported_properties) { ov::device::capabilities, ov::device::priorities, ov::hint::model_distribution_policy}; - auto actual_supported_properties = core.get_property("HETERO", ov::supported_properties); + auto actual_supported_properties = core.get_property(ov::test::utils::DEVICE_HETERO, ov::supported_properties); EXPECT_EQ(supported_properties.size(), actual_supported_properties.size()); for (auto& supported_property : supported_properties) { ASSERT_TRUE(std::find(actual_supported_properties.begin(), @@ -24,7 +27,8 @@ TEST_F(HeteroTests, get_property_supported_properties) { TEST_F(HeteroTests, get_property_internal_supported_properties) { const std::vector supported_properties = {ov::internal::caching_properties}; - auto actual_supported_properties = core.get_property("HETERO", ov::internal::supported_properties); + auto actual_supported_properties = + core.get_property(ov::test::utils::DEVICE_HETERO, ov::internal::supported_properties); EXPECT_EQ(supported_properties.size(), actual_supported_properties.size()); for (auto& supported_property : supported_properties) { ASSERT_TRUE(std::find(actual_supported_properties.begin(), @@ -34,28 +38,33 @@ TEST_F(HeteroTests, get_property_internal_supported_properties) { } TEST_F(HeteroTests, get_property_ro_properties) { - EXPECT_EQ("HETERO", core.get_property("HETERO", ov::device::full_name)); + EXPECT_EQ(ov::test::utils::DEVICE_HETERO, core.get_property(ov::test::utils::DEVICE_HETERO, ov::device::full_name)); EXPECT_EQ(std::vector{ov::device::capability::EXPORT_IMPORT}, - core.get_property("HETERO", ov::device::capabilities)); + core.get_property(ov::test::utils::DEVICE_HETERO, ov::device::capabilities)); } TEST_F(HeteroTests, set_property_device_priorities) { - EXPECT_EQ("", core.get_property("HETERO", ov::device::priorities)); - core.set_property("HETERO", ov::device::priorities("MOCK0,MOCK1")); - EXPECT_EQ("MOCK0,MOCK1", core.get_property("HETERO", ov::device::priorities)); + EXPECT_EQ("", core.get_property(ov::test::utils::DEVICE_HETERO, ov::device::priorities)); + core.set_property(ov::test::utils::DEVICE_HETERO, ov::device::priorities("MOCK0,MOCK1")); + EXPECT_EQ("MOCK0,MOCK1", core.get_property(ov::test::utils::DEVICE_HETERO, ov::device::priorities)); } TEST_F(HeteroTests, set_property_ModelDistributionPolicy) { std::set value = {}; std::set model_policy = {ov::hint::ModelDistributionPolicy::PIPELINE_PARALLEL}; - OV_ASSERT_NO_THROW(core.set_property("HETERO", ov::hint::model_distribution_policy(model_policy))); - OV_ASSERT_NO_THROW(value = core.get_property("HETERO", ov::hint::model_distribution_policy)); + ASSERT_NO_THROW( + core.set_property(ov::test::utils::DEVICE_HETERO, ov::hint::model_distribution_policy(model_policy))); + ASSERT_NO_THROW(value = core.get_property(ov::test::utils::DEVICE_HETERO, ov::hint::model_distribution_policy)); ASSERT_EQ(model_policy, value); model_policy = {}; - OV_ASSERT_NO_THROW(core.set_property("HETERO", ov::hint::model_distribution_policy(model_policy))); - OV_ASSERT_NO_THROW(value = core.get_property("HETERO", ov::hint::model_distribution_policy)); + ASSERT_NO_THROW( + core.set_property(ov::test::utils::DEVICE_HETERO, ov::hint::model_distribution_policy(model_policy))); + ASSERT_NO_THROW(value = core.get_property(ov::test::utils::DEVICE_HETERO, ov::hint::model_distribution_policy)); ASSERT_EQ(model_policy, value); -} \ No newline at end of file +} +} // namespace tests +} // namespace hetero +} // namespace ov \ No newline at end of file diff --git a/src/plugins/hetero/tests/functional/query_model_tests.cpp b/src/plugins/hetero/tests/functional/query_model_tests.cpp index 7065255bf9acd3..c322326ea41b28 100644 --- a/src/plugins/hetero/tests/functional/query_model_tests.cpp +++ b/src/plugins/hetero/tests/functional/query_model_tests.cpp @@ -1,16 +1,18 @@ // Copyright (C) 2018-2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // +#include "common_test_utils/test_constants.hpp" #include "hetero_tests.hpp" -using namespace ov::hetero::tests; - -// AVAILABLE_DEVICES {"MOCK0.0", "MOCK0.1", "MOCK0.2", "MOCK1.0", "MOCK1.0"}; +namespace ov { +namespace hetero { +namespace tests { TEST_F(HeteroTests, query_model_on_mock0) { const std::string dev_name = "MOCK0.1"; const auto model = create_model_with_subtract_reshape(); - const auto supported_ops = core.query_model(model, "HETERO", {ov::device::priorities(dev_name)}); + const auto supported_ops = + core.query_model(model, ov::test::utils::DEVICE_HETERO, {ov::device::priorities(dev_name)}); std::unordered_set names; for (const auto& op : model->get_ops()) { names.insert(op->get_friendly_name()); @@ -28,7 +30,8 @@ TEST_F(HeteroTests, query_model_on_mock1) { const auto model = create_model_with_subtract_reshape(); // This WA is needed because mock plugins are loaded one by one EXPECT_NO_THROW(core.get_available_devices()); - const auto supported_ops = core.query_model(model, "HETERO", {ov::device::priorities(dev_name)}); + const auto supported_ops = + core.query_model(model, ov::test::utils::DEVICE_HETERO, {ov::device::priorities(dev_name)}); std::unordered_set names; for (const auto& op : model->get_ops()) { names.insert(op->get_friendly_name()); @@ -57,7 +60,7 @@ TEST_F(HeteroTests, query_model_on_mixed) { if (op.second == dev_name0) supported_ops_mock0.insert(op.first); } - const auto supported_ops = core.query_model(model, "HETERO", config); + const auto supported_ops = core.query_model(model, ov::test::utils::DEVICE_HETERO, config); std::unordered_set names; for (const auto& op : model->get_ops()) { names.insert(op->get_friendly_name()); @@ -82,7 +85,7 @@ TEST_F(HeteroTests, query_dynamic_model_on_mixed) { if (op.second == dev_name0) supported_ops_mock0.insert(op.first); } - const auto supported_ops = core.query_model(model, "HETERO", config); + const auto supported_ops = core.query_model(model, ov::test::utils::DEVICE_HETERO, config); std::unordered_set names; for (const auto& op : model->get_ops()) { names.insert(op->get_friendly_name()); @@ -103,7 +106,8 @@ TEST_F(HeteroTests, query_model_on_independent_parameter) { ov::SupportedOpsMap supported_ops; const std::string dev_name = "MOCK0.1"; const auto model = create_model_with_independent_parameter(); - OV_ASSERT_NO_THROW(supported_ops = core.query_model(model, "HETERO", {ov::device::priorities(dev_name)})); + ASSERT_NO_THROW(supported_ops = + core.query_model(model, ov::test::utils::DEVICE_HETERO, {ov::device::priorities(dev_name)})); std::unordered_set names; for (const auto& op : model->get_ops()) { names.insert(op->get_friendly_name()); @@ -124,7 +128,7 @@ TEST_F(HeteroTests, query_model_by_three_device) { EXPECT_NO_THROW(core.get_available_devices()); const auto model = create_model_with_multi_add(); const auto supported_ops = core.query_model(model, - "HETERO", + ov::test::utils::DEVICE_HETERO, {ov::device::priorities(dev_name0 + "," + dev_name1 + "," + dev_name2), ov::hint::model_distribution_policy(model_policy)}); std::map expect_result = {{"input", "MOCKGPU.2"}, @@ -154,7 +158,7 @@ TEST_F(HeteroTests, query_model_by_two_device) { const auto model = create_model_with_multi_add(); const auto supported_ops = core.query_model( model, - "HETERO", + ov::test::utils::DEVICE_HETERO, {ov::device::priorities(dev_name0 + "," + dev_name1), ov::hint::model_distribution_policy(model_policy)}); std::map expect_result = {{"input", "MOCKGPU.2"}, {"const_val1", "MOCKGPU.2"}, @@ -171,4 +175,7 @@ TEST_F(HeteroTests, query_model_by_two_device) { EXPECT_EQ(op.second, expect_result[op.first]); } } -} \ No newline at end of file +} +} // namespace tests +} // namespace hetero +} // namespace ov \ No newline at end of file diff --git a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_compiled_model/properties.cpp b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_compiled_model/properties.cpp index 558567e45f7ec3..11bd48ab42e8c0 100644 --- a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_compiled_model/properties.cpp +++ b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_compiled_model/properties.cpp @@ -5,11 +5,12 @@ #include "behavior/compiled_model/properties.hpp" #include "behavior/compiled_model/properties_hetero.hpp" +#include "common_test_utils/test_constants.hpp" #include "openvino/runtime/properties.hpp" -using namespace ov::test::behavior; - -namespace { +namespace ov { +namespace test { +namespace behavior { const std::vector inproperties = { {ov::device::id("UNSUPPORTED_DEVICE_ID_STRING")}, @@ -20,6 +21,42 @@ const std::vector hetero_properties = { {ov::device::priorities(ov::test::utils::DEVICE_TEMPLATE), ov::device::id("0")}, }; +const std::vector heteroConfigsWithSecondaryProperties = { + {ov::device::priorities(ov::test::utils::DEVICE_CPU), + ov::device::properties(ov::test::utils::DEVICE_HETERO, + ov::enable_profiling(false), + ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT))}, + {ov::device::priorities(ov::test::utils::DEVICE_CPU), + ov::device::properties("CPU", + ov::num_streams(4), + ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT))}, + {ov::device::priorities(ov::test::utils::DEVICE_CPU), + ov::device::properties("CPU", + ov::num_streams(4), + ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT)), + ov::device::properties("GPU", ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY))}, + {ov::device::priorities(ov::test::utils::DEVICE_CPU), + ov::device::properties(ov::test::utils::DEVICE_HETERO, + ov::enable_profiling(false), + ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY)), + ov::device::properties("CPU", + ov::num_streams(4), + ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT))}, + {ov::device::priorities(ov::test::utils::DEVICE_GPU), + ov::device::properties(ov::test::utils::DEVICE_HETERO, + ov::enable_profiling(false), + ov::device::priorities(ov::test::utils::DEVICE_CPU), + ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY)), + ov::device::properties("CPU", + ov::num_streams(4), + ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT)), + ov::device::properties("GPU", ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY))}}; + +INSTANTIATE_TEST_SUITE_P(nightly_HETERO_OVClassCompileModelWithCorrectPropertiesTest, + OVClassCompileModelWithCorrectPropertiesTest, + ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), + ::testing::ValuesIn(heteroConfigsWithSecondaryProperties))); + INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVClassCompiledModelPropertiesIncorrectTests, ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), @@ -36,10 +73,16 @@ INSTANTIATE_TEST_SUITE_P(smoke_OVClassCompiledModelGetPropertyTest, OVClassCompiledModelGetPropertyTest, ::testing::Values("HETERO:TEMPLATE")); +INSTANTIATE_TEST_SUITE_P(smoke_OVClassCompiledModelGetIncorrectPropertyTest, + OVClassCompiledModelGetIncorrectPropertyTest, + ::testing::Values("HETERO:TEMPLATE")); + INSTANTIATE_TEST_SUITE_P(smoke_OVClassHeteroCompiledModelGetMetricTest, OVClassHeteroCompiledModelGetMetricTest_TARGET_FALLBACK, ::testing::Values(ov::test::utils::DEVICE_TEMPLATE)); INSTANTIATE_TEST_SUITE_P(smoke_OVClassHeteroCompiledModelGetMetricTest, OVClassHeteroCompiledModelGetMetricTest_EXEC_DEVICES, ::testing::Values("TEMPLATE.0")); -} // namespace +} // namespace behavior +} // namespace test +} // namespace ov diff --git a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_infer_request/gpu_dyn_batch_shape_tests.cpp b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_infer_request/gpu_dyn_batch_shape_tests.cpp new file mode 100644 index 00000000000000..d0ac21a884fc35 --- /dev/null +++ b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_infer_request/gpu_dyn_batch_shape_tests.cpp @@ -0,0 +1,129 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "common_test_utils/file_utils.hpp" +#include "common_test_utils/ov_plugin_cache.hpp" +#include "common_test_utils/subgraph_builders/split_multi_conv_concat.hpp" +#include "common_test_utils/test_common.hpp" +#include "openvino/runtime/core.hpp" +#include "shared_test_classes/base/ov_subgraph.hpp" + +namespace ov { +namespace test { + +using OVDynamicBatchParams = std::tuple, // dynamic and static case sizes + ov::element::Type, // Model type + std::string, // Device name + ov::AnyMap // Config + >; + +class OVDynamicBatchShape_Tests : public ::testing::WithParamInterface, + virtual public ov::test::SubgraphBaseTest { +public: + static std::string getTestCaseName(::testing::TestParamInfo obj) { + std::vector input_shapes; + ov::element::Type model_type; + std::string target_device; + ov::AnyMap configuration; + std::tie(input_shapes, model_type, target_device, configuration) = obj.param; + + std::ostringstream result; + result << "IS="; + for (const auto& shape : input_shapes) { + result << ov::test::utils::partialShape2str({shape.first}) << "_"; + } + result << "TS="; + for (const auto& shape : input_shapes) { + result << "("; + if (!shape.second.empty()) { + for (const auto& itr : shape.second) { + result << ov::test::utils::vec2str(itr); + } + } + result << ")_"; + } + result << "netPRC=" << model_type << "_"; + result << "targetDevice=" << target_device; + if (!configuration.empty()) { + for (auto& configItem : configuration) { + result << "configItem=" << configItem.first << "_"; + configItem.second.print(result); + result << "_"; + } + } + return result.str(); + } + +protected: + void SetUp() override { + if (core) { + core.reset(); + core = ov::test::utils::PluginCache::get().core(); + } + std::vector input_shape; + + std::tie(input_shape, model_type, targetDevice, configuration) = this->GetParam(); + + init_input_shapes(input_shape); + // TODO: think how we can switch between several input topologies in the future + // function = ov::test::utils::make_split_conv_concat(input_shape.front().first.get_min_shape(), model_type); + function = ov::test::utils::make_split_multi_conv_concat(input_shape.front().first.get_min_shape(), model_type); + + // make topology dynamic + std::map dynShape; + dynShape["input_tensor"] = input_shape.front().first; + function->reshape(dynShape); + } + + ov::element::Type model_type; +}; + +TEST_P(OVDynamicBatchShape_Tests, InferDynamicBatchBound) { + SKIP_IF_CURRENT_TEST_IS_DISABLED() + run(); +} + +TEST_P(OVDynamicBatchShape_Tests, InferDynamicBatchBound_cached) { + SKIP_IF_CURRENT_TEST_IS_DISABLED() + std::string cacheFolderName; + { + std::stringstream ss; + ss << "InferDynamicBatchBound_cached_" << model_type << "_" << targetDevice; + cacheFolderName = ss.str(); + + ov::test::utils::removeFilesWithExt(cacheFolderName, "blob"); + ov::test::utils::removeFilesWithExt(cacheFolderName, "cl_cache"); + ov::test::utils::removeDir(cacheFolderName); + + core->set_property(ov::cache_dir(cacheFolderName)); + run(); + } + { + core.reset(); + core = ov::test::utils::PluginCache::get().core(); + core->set_property(ov::cache_dir(cacheFolderName)); + run(); + + ov::test::utils::removeFilesWithExt(cacheFolderName, "blob"); + ov::test::utils::removeFilesWithExt(cacheFolderName, "cl_cache"); + ov::test::utils::removeDir(cacheFolderName); + } +} + +auto hetero_config = ov::AnyMap{{ov::device::priorities.name(), ov::test::utils::DEVICE_GPU}}; + +const std::vector input_shapes = { + {{{1, 19}, 4, 20, 20}, {{1, 4, 20, 20}, {7, 4, 20, 20}, {17, 4, 20, 20}}}}; + +const std::vector model_types = {ov::element::f16, ov::element::f32}; + +INSTANTIATE_TEST_SUITE_P(nightly_GPU_DynBatchHetero, + OVDynamicBatchShape_Tests, + ::testing::Combine(::testing::Values(input_shapes), + ::testing::ValuesIn(model_types), + ::testing::Values(ov::test::utils::DEVICE_HETERO), + ::testing::Values(hetero_config)), + OVDynamicBatchShape_Tests::getTestCaseName); +} // namespace test +} // namespace ov diff --git a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_infer_request/iteration_chaining.cpp b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_infer_request/iteration_chaining.cpp new file mode 100644 index 00000000000000..de71584e291a36 --- /dev/null +++ b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_infer_request/iteration_chaining.cpp @@ -0,0 +1,23 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_infer_request/iteration_chaining.hpp" + +namespace ov { +namespace test { +namespace behavior { + +const std::vector HeteroConfigs = { + {{ov::hint::inference_precision.name(), ov::element::f32}, + {ov::device::priorities(ov::test::utils::DEVICE_TEMPLATE)}}, +}; + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, + OVIterationChaining, + ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), + ::testing::ValuesIn(HeteroConfigs)), + OVIterationChaining::getTestCaseName); +} // namespace behavior +} // namespace test +} // namespace ov diff --git a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_infer_request/memory_states.cpp b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_infer_request/memory_states.cpp new file mode 100644 index 00000000000000..b16992d6ac7bd4 --- /dev/null +++ b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_infer_request/memory_states.cpp @@ -0,0 +1,22 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_infer_request/memory_states.hpp" + +namespace ov { +namespace test { +namespace behavior { +std::vector memoryStateTestCases = { + memoryStateParams(OVInferRequestVariableStateTest::get_network(), + {"c_1-3", "r_1-3"}, + ov::test::utils::DEVICE_HETERO, + {ov::device::priorities(ov::test::utils::DEVICE_TEMPLATE)})}; + +INSTANTIATE_TEST_SUITE_P(smoke_VariableState, + OVInferRequestVariableStateTest, + ::testing::ValuesIn(memoryStateTestCases), + OVInferRequestVariableStateTest::getTestCaseName); +} // namespace behavior +} // namespace test +} // namespace ov \ No newline at end of file diff --git a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/caching_tests.cpp b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/caching_tests.cpp new file mode 100644 index 00000000000000..556af70224fa34 --- /dev/null +++ b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/caching_tests.cpp @@ -0,0 +1,52 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_plugin/caching_tests.hpp" + +#include "ov_ops/multiclass_nms_ie_internal.hpp" +#include "ov_ops/nms_ie_internal.hpp" +#include "ov_ops/nms_static_shape_ie.hpp" + +namespace ov { +namespace test { +namespace behavior { + +static const std::vector precisions = { + ov::element::f32, + ov::element::f16, + ov::element::i32, + ov::element::i64, +}; + +static const std::vector floatprecisions = { + ov::element::f32, + ov::element::f16, +}; + +static const std::vector batchSizes = {1, 2}; + +const std::vector autoConfigs = {{ov::device::priorities(ov::test::utils::DEVICE_TEMPLATE)}}; + +INSTANTIATE_TEST_SUITE_P( + smoke_Hetero_CachingSupportCase, + CompileModelCacheTestBase, + ::testing::Combine(::testing::ValuesIn(CompileModelCacheTestBase::getNumericAnyTypeFunctions()), + ::testing::ValuesIn(precisions), + ::testing::ValuesIn(batchSizes), + ::testing::Values(ov::test::utils::DEVICE_HETERO), + ::testing::ValuesIn(autoConfigs)), + CompileModelCacheTestBase::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P( + smoke_Hetero_CachingSupportCase_Float, + CompileModelCacheTestBase, + ::testing::Combine(::testing::ValuesIn(CompileModelCacheTestBase::getFloatingPointOnlyFunctions()), + ::testing::ValuesIn(floatprecisions), + ::testing::ValuesIn(batchSizes), + ::testing::Values(ov::test::utils::DEVICE_HETERO), + ::testing::ValuesIn(autoConfigs)), + CompileModelCacheTestBase::getTestCaseName); +} // namespace behavior +} // namespace test +} // namespace ov diff --git a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/core_threading_tests.cpp b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/core_threading_tests.cpp new file mode 100644 index 00000000000000..4254e9a938143d --- /dev/null +++ b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/core_threading_tests.cpp @@ -0,0 +1,22 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_plugin/core_threading.hpp" + +namespace { +const Params params[] = { + std::tuple{ov::test::utils::DEVICE_HETERO, + {{ov::device::priorities.name(), ov::test::utils::DEVICE_CPU}}}, +}; +} // namespace + +INSTANTIATE_TEST_SUITE_P(nightly_HETERO, + CoreThreadingTest, + testing::ValuesIn(params), + CoreThreadingTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(HETERO_Streams, + CoreThreadingTestsWithIter, + testing::Combine(testing::ValuesIn(params), testing::Values(4), testing::Values(50)), + CoreThreadingTestsWithIter::getTestCaseName); \ No newline at end of file diff --git a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp index 4e4293325478b0..c2df81bc5266f1 100644 --- a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp +++ b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp @@ -1,16 +1,21 @@ -// Copyright (C) 2018-2023 Intel Corporation +// Copyright (C) 2018-2024 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // #include "behavior/ov_plugin/life_time.hpp" -using namespace ov::test::behavior; +namespace ov { +namespace test { +namespace behavior { +INSTANTIATE_TEST_SUITE_P(smoke_VirtualPlugin_BehaviorTests, + OVHoldersTest, + ::testing::Values("HETERO:TEMPLATE"), + OVHoldersTest::getTestCaseName); -namespace { - -INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, - OVHoldersTestOnImportedNetwork, - ::testing::Values(ov::test::utils::DEVICE_TEMPLATE, "HETERO:TEMPLATE"), - OVHoldersTestOnImportedNetwork::getTestCaseName); - -} // namespace +INSTANTIATE_TEST_SUITE_P(nightly_VirtualPlugin_BehaviorTests, + OVHoldersTest, + ::testing::Values("HETERO:GPU"), + OVHoldersTest::getTestCaseName); +} // namespace behavior +} // namespace test +} // namespace ov diff --git a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp index fa920d5b14ea99..5b691e8ec83328 100644 --- a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp +++ b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp @@ -4,11 +4,12 @@ #include "behavior/ov_plugin/properties_tests.hpp" +#include "behavior/compiled_model/properties.hpp" #include "openvino/runtime/properties.hpp" -using namespace ov::test::behavior; - -namespace { +namespace ov { +namespace test { +namespace behavior { const std::vector inproperties = { {ov::device::id("UNSUPPORTED_DEVICE_ID_STRING")}, @@ -30,4 +31,54 @@ INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), ::testing::ValuesIn(hetero_properties)), OVPropertiesTests::getTestCaseName); -} // namespace + +INSTANTIATE_TEST_SUITE_P(smoke_HeteroOVGetMetricPropsTest, + OVGetMetricPropsTest, + ::testing::Values(ov::test::utils::DEVICE_HETERO)); + +INSTANTIATE_TEST_SUITE_P( + smoke_HeteroOVCheckGetSupportedROMetricsPropsTests, + OVCheckGetSupportedROMetricsPropsTests, + ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), + ::testing::ValuesIn(OVCheckGetSupportedROMetricsPropsTests::configureProperties( + {ov::device::full_name.name()}))), + OVCheckGetSupportedROMetricsPropsTests::getTestCaseName); + +const std::vector multiConfigs = {{ov::device::priorities(ov::test::utils::DEVICE_TEMPLATE)}}; + +INSTANTIATE_TEST_SUITE_P(smoke_OVClassSetDevicePriorityConfigPropsTest, + OVClassSetDevicePriorityConfigPropsTest, + ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), + ::testing::ValuesIn(multiConfigs))); + +INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetPropertyTest, + OVClassCompiledModelGetPropertyTest, + ::testing::Values("HETERO:GPU")); + +INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetIncorrectPropertyTest, + OVClassCompiledModelGetIncorrectPropertyTest, + ::testing::Values("HETERO:GPU")); + +auto gpuCorrectConfigsWithSecondaryProperties = []() { + return std::vector{ + {ov::device::properties(ov::test::utils::DEVICE_GPU, + ov::hint::execution_mode(ov::hint::ExecutionMode::PERFORMANCE), + ov::hint::inference_precision(ov::element::f32))}, + {ov::device::properties(ov::test::utils::DEVICE_GPU, + ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT), + ov::hint::allow_auto_batching(false))}, + {ov::device::properties(ov::test::utils::DEVICE_GPU, + ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT), + ov::hint::allow_auto_batching(false)), + ov::device::properties(ov::test::utils::DEVICE_CPU, + ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY), + ov::hint::allow_auto_batching(false))}}; +}; + +INSTANTIATE_TEST_SUITE_P(nightly_HETERO_OVClassCompileModelWithCorrectSecondaryPropertiesTest, + OVClassCompileModelWithCorrectPropertiesTest, + ::testing::Combine(::testing::Values("HETERO:GPU"), + ::testing::ValuesIn(gpuCorrectConfigsWithSecondaryProperties()))); +} // namespace behavior +} // namespace test +} // namespace ov diff --git a/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp new file mode 100644 index 00000000000000..d16beb6be96166 --- /dev/null +++ b/src/plugins/hetero/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp @@ -0,0 +1,18 @@ +// Copyright (C) 2018-2024 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_plugin/version.hpp" + +namespace ov { +namespace test { +namespace behavior { + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, + VersionTests, + ::testing::Values(ov::test::utils::DEVICE_HETERO), + VersionTests::getTestCaseName); + +} // namespace behavior +} // namespace test +} // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/core_integration.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/core_integration.cpp index b4b478d43bf2ae..d8cbbe4debbbb9 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/core_integration.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/core_integration.cpp @@ -13,9 +13,9 @@ namespace { // Executable Network GetMetric // -INSTANTIATE_TEST_SUITE_P( - smoke_OVClassCompiledModelGetPropertyTest, OVClassCompiledModelGetPropertyTest, - ::testing::Values("CPU", "HETERO:CPU")); +INSTANTIATE_TEST_SUITE_P(smoke_OVClassCompiledModelGetPropertyTest, + OVClassCompiledModelGetPropertyTest, + ::testing::Values("CPU")); const std::vector>> GetMetricTest_ExecutionDevice_CPU = { {"CPU", std::make_pair(ov::AnyMap{}, "CPU")}}; @@ -28,9 +28,9 @@ INSTANTIATE_TEST_SUITE_P( // Executable Network GetConfig / SetConfig // -INSTANTIATE_TEST_SUITE_P( - smoke_OVClassCompiledModelGetIncorrectPropertyTest, OVClassCompiledModelGetIncorrectPropertyTest, - ::testing::Values("CPU", "HETERO:CPU")); +INSTANTIATE_TEST_SUITE_P(smoke_OVClassCompiledModelGetIncorrectPropertyTest, + OVClassCompiledModelGetIncorrectPropertyTest, + ::testing::Values("CPU")); INSTANTIATE_TEST_SUITE_P( smoke_OVClassCompiledModelGetConfigTest, OVClassCompiledModelGetConfigTest, diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/properties.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/properties.cpp index 86a3d724d2ba8e..f15127c1dab1e2 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/properties.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/properties.cpp @@ -3,7 +3,6 @@ // #include "behavior/compiled_model/properties.hpp" -#include "behavior/compiled_model/properties_hetero.hpp" #include "openvino/runtime/properties.hpp" #include "openvino/runtime/system_conf.hpp" @@ -16,23 +15,12 @@ const std::vector inproperties = { {ov::num_streams(-100)}, }; -const std::vector auto_batch_inproperties = { - {ov::num_streams(-100)}, -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVClassCompiledModelPropertiesIncorrectTests, - ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_CPU, - ov::test::utils::DEVICE_HETERO), + ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_CPU), ::testing::ValuesIn(inproperties)), OVClassCompiledModelPropertiesIncorrectTests::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, - OVClassCompiledModelPropertiesIncorrectTests, - ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(auto_batch_inproperties)), - OVClassCompiledModelPropertiesIncorrectTests::getTestCaseName); - #if (defined(__APPLE__) || defined(_WIN32)) auto default_affinity = [] { auto numaNodes = ov::get_available_numa_nodes(); @@ -76,34 +64,12 @@ const std::vector properties = {{ov::num_streams(ov::streams::NUMA)} {ov::num_streams(0), ov::inference_num_threads(1)}, {ov::num_streams(1), ov::inference_num_threads(1)}}; -const std::vector hetero_properties = { - {ov::device::priorities(ov::test::utils::DEVICE_CPU), ov::num_streams(ov::streams::AUTO)}, -}; - -const std::vector auto_batch_properties = { - {ov::device::priorities(std::string(ov::test::utils::DEVICE_CPU) + "(4)")}, - {ov::device::priorities(std::string(ov::test::utils::DEVICE_CPU) + "(4)"), ov::auto_batch_timeout(1)}, - {ov::device::priorities(std::string(ov::test::utils::DEVICE_CPU) + "(4)"), ov::auto_batch_timeout(10)}, -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVClassCompiledModelPropertiesTests, ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_CPU), ::testing::ValuesIn(properties)), OVClassCompiledModelPropertiesTests::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, - OVClassCompiledModelPropertiesTests, - ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), - ::testing::ValuesIn(hetero_properties)), - OVClassCompiledModelPropertiesTests::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, - OVClassCompiledModelPropertiesTests, - ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(auto_batch_properties)), - OVClassCompiledModelPropertiesTests::getTestCaseName); - INSTANTIATE_TEST_SUITE_P(smoke_OVCompiledModelIncorrectDevice, OVCompiledModelIncorrectDevice, ::testing::Values("CPU")); const std::vector configsWithSecondaryProperties = { @@ -116,59 +82,19 @@ const std::vector configsWithSecondaryProperties = { ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT)), ov::device::properties("GPU", ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY))}}; -const std::vector heteroConfigsWithSecondaryProperties = { - {ov::device::priorities(ov::test::utils::DEVICE_CPU), - ov::device::properties("HETERO", - ov::enable_profiling(false), - ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT))}, - {ov::device::priorities(ov::test::utils::DEVICE_CPU), - ov::device::properties("CPU", - ov::num_streams(4), - ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT))}, - {ov::device::priorities(ov::test::utils::DEVICE_CPU), - ov::device::properties("CPU", - ov::num_streams(4), - ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT)), - ov::device::properties("GPU", ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY))}, - {ov::device::priorities(ov::test::utils::DEVICE_CPU), - ov::device::properties("HETERO", - ov::enable_profiling(false), - ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY)), - ov::device::properties("CPU", - ov::num_streams(4), - ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT))}, - {ov::device::priorities(ov::test::utils::DEVICE_GPU), - ov::device::properties("HETERO", - ov::enable_profiling(false), - ov::device::priorities(ov::test::utils::DEVICE_CPU), - ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY)), - ov::device::properties("CPU", - ov::num_streams(4), - ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT)), - ov::device::properties("GPU", ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY))}}; - // OV Class Load network INSTANTIATE_TEST_SUITE_P(smoke_CPUOVClassCompileModelWithCorrectPropertiesTest, OVClassCompileModelWithCorrectPropertiesTest, - ::testing::Combine(::testing::Values("CPU", "HETERO:CPU"), + ::testing::Combine(::testing::Values("CPU"), ::testing::ValuesIn(configsWithSecondaryProperties))); -INSTANTIATE_TEST_SUITE_P(smoke_HETERO_OVClassCompileModelWithCorrectPropertiesTest, - OVClassCompileModelWithCorrectPropertiesTest, - ::testing::Combine(::testing::Values("HETERO"), - ::testing::ValuesIn(heteroConfigsWithSecondaryProperties))); - // // OV CompiledModel Get RO Property // -// -// Executable Network GetMetric -// - -INSTANTIATE_TEST_SUITE_P( - smoke_OVClassCompiledModelGetPropertyTest, OVClassCompiledModelGetPropertyTest, - ::testing::Values("CPU", "HETERO:CPU")); +INSTANTIATE_TEST_SUITE_P(smoke_OVClassCompiledModelGetPropertyTest, + OVClassCompiledModelGetPropertyTest, + ::testing::Values("CPU")); const std::vector>> GetMetricTest_ExecutionDevice_CPU = { {"CPU", std::make_pair(ov::AnyMap{}, "CPU")}}; @@ -181,9 +107,9 @@ INSTANTIATE_TEST_SUITE_P( // OV CompiledModel GetProperty / SetProperty // -INSTANTIATE_TEST_SUITE_P( - smoke_OVClassCompiledModelGetIncorrectPropertyTest, OVClassCompiledModelGetIncorrectPropertyTest, - ::testing::Values("CPU", "HETERO:CPU")); +INSTANTIATE_TEST_SUITE_P(smoke_OVClassCompiledModelGetIncorrectPropertyTest, + OVClassCompiledModelGetIncorrectPropertyTest, + ::testing::Values("CPU")); INSTANTIATE_TEST_SUITE_P( smoke_OVClassCompiledModelGetConfigTest, OVClassCompiledModelGetConfigTest, @@ -192,17 +118,4 @@ INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P( smoke_OVClassCompiledModelSetIncorrectConfigTest, OVClassCompiledModelSetIncorrectConfigTest, ::testing::Values("CPU")); - -// -// Hetero OV CompiledModel Get RO Property -// - -INSTANTIATE_TEST_SUITE_P( - smoke_OVClassHeteroExecutableNetworkGetMetricTest, OVClassHeteroCompiledModelGetMetricTest_SUPPORTED_CONFIG_KEYS, - ::testing::Values("CPU")); - -INSTANTIATE_TEST_SUITE_P( - smoke_OVClassHeteroExecutableNetworkGetMetricTest, OVClassHeteroCompiledModelGetMetricTest_TARGET_FALLBACK, - ::testing::Values("CPU")); - } // namespace diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/infer_request_dynamic.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/infer_request_dynamic.cpp index 3e5f9d3efaefcd..8d973fabc5c73b 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/infer_request_dynamic.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/infer_request_dynamic.cpp @@ -13,10 +13,6 @@ namespace { const std::vector configs = {{{ov::hint::inference_precision.name(), ov::element::f32}}}; -const std::vector HeteroConfigs = { - {{ov::hint::inference_precision.name(), ov::element::f32}, {ov::device::priorities(ov::test::utils::DEVICE_CPU)}}, -}; - std::shared_ptr getFunction1() { const std::vector inputShape = {1, 4, 20, 20}; const ov::element::Type_t ngPrc = ov::element::Type_t::f32; @@ -82,15 +78,4 @@ INSTANTIATE_TEST_SUITE_P( ::testing::Values(ov::test::utils::DEVICE_CPU), ::testing::ValuesIn(configs)), OVInferRequestDynamicTests::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P( - smoke_Hetero_BehaviorTests, - OVInferRequestDynamicTests, - ::testing::Combine(::testing::Values(getFunction2()), - ::testing::Values(std::vector, std::vector>>{ - {{1, 4, 20, 20}, {1, 2, 20, 40}}, - {{2, 4, 20, 20}, {2, 2, 20, 40}}}), - ::testing::Values(ov::test::utils::DEVICE_HETERO), - ::testing::ValuesIn(HeteroConfigs)), - OVInferRequestDynamicTests::getTestCaseName); } // namespace diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/inference_chaining.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/inference_chaining.cpp index f42774120178f8..55a20f6e01e26a 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/inference_chaining.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/inference_chaining.cpp @@ -10,29 +10,15 @@ namespace { const std::vector configs = {{}}; -const std::vector HeteroConfigs = {{ov::device::priorities(ov::test::utils::DEVICE_CPU)}}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferenceChaining, ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_CPU), ::testing::ValuesIn(configs)), OVInferenceChaining::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, - OVInferenceChaining, - ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), - ::testing::ValuesIn(HeteroConfigs)), - OVInferenceChaining::getTestCaseName); - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferenceChainingStatic, ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_CPU), ::testing::ValuesIn(configs)), OVInferenceChainingStatic::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, - OVInferenceChainingStatic, - ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), - ::testing::ValuesIn(HeteroConfigs)), - OVInferenceChainingStatic::getTestCaseName); } // namespace diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/iteration_chaining.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/iteration_chaining.cpp index 3d7ce616cc653b..c4089d62f477df 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/iteration_chaining.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/iteration_chaining.cpp @@ -10,19 +10,9 @@ namespace { const std::vector configs = {{{ov::hint::inference_precision.name(), ov::element::f32}}}; -const std::vector HeteroConfigs = { - {{ov::hint::inference_precision.name(), ov::element::f32}, {ov::device::priorities(ov::test::utils::DEVICE_CPU)}}, -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVIterationChaining, ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_CPU), ::testing::ValuesIn(configs)), OVIterationChaining::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, - OVIterationChaining, - ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), - ::testing::ValuesIn(HeteroConfigs)), - OVIterationChaining::getTestCaseName); } // namespace diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/memory_states.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/memory_states.cpp index 480521af03f756..bc58e06c007dd9 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/memory_states.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/memory_states.cpp @@ -8,15 +8,10 @@ using namespace ov::test::behavior; using namespace ov; namespace { -std::vector memoryStateTestCases = { - memoryStateParams(OVInferRequestVariableStateTest::get_network(), - {"c_1-3", "r_1-3"}, - ov::test::utils::DEVICE_CPU, - {}), - memoryStateParams(OVInferRequestVariableStateTest::get_network(), - {"c_1-3", "r_1-3"}, - ov::test::utils::DEVICE_HETERO, - {ov::device::priorities(ov::test::utils::DEVICE_CPU)})}; +std::vector memoryStateTestCases = {memoryStateParams(OVInferRequestVariableStateTest::get_network(), + {"c_1-3", "r_1-3"}, + ov::test::utils::DEVICE_CPU, + {})}; INSTANTIATE_TEST_SUITE_P(smoke_VariableState, OVInferRequestVariableStateTest, diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/caching_tests.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/caching_tests.cpp index d11fd279d9238f..e0ab9510a5b0a6 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/caching_tests.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/caching_tests.cpp @@ -112,28 +112,6 @@ namespace { ::testing::Values(ov::AnyMap{})), CompileModelCacheTestBase::getTestCaseName); - const std::vector autoConfigs = { - {ov::device::priorities(ov::test::utils::DEVICE_CPU)} - }; - - INSTANTIATE_TEST_SUITE_P(smoke_Hetero_CachingSupportCase, CompileModelCacheTestBase, - ::testing::Combine( - ::testing::ValuesIn(CompileModelCacheTestBase::getNumericAnyTypeFunctions()), - ::testing::ValuesIn(precisionsCPU), - ::testing::ValuesIn(batchSizesCPU), - ::testing::Values(ov::test::utils::DEVICE_HETERO), - ::testing::ValuesIn(autoConfigs)), - CompileModelCacheTestBase::getTestCaseName); - - INSTANTIATE_TEST_SUITE_P(smoke_Hetero_CachingSupportCase_Float, CompileModelCacheTestBase, - ::testing::Combine( - ::testing::ValuesIn(CompileModelCacheTestBase::getFloatingPointOnlyFunctions()), - ::testing::ValuesIn(floatPrecisionsCPU), - ::testing::ValuesIn(batchSizesCPU), - ::testing::Values(ov::test::utils::DEVICE_HETERO), - ::testing::ValuesIn(autoConfigs)), - CompileModelCacheTestBase::getTestCaseName); - const std::vector CpuConfigs = { {ov::num_streams(2)}, }; diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/core_threading_tests.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/core_threading_tests.cpp index 6192be76cb3e1a..b2fd807d981f9c 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/core_threading_tests.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/core_threading_tests.cpp @@ -7,7 +7,6 @@ namespace { const Params params[] = { std::tuple{ov::test::utils::DEVICE_CPU, {{ov::enable_profiling(true)}}}, - std::tuple{ov::test::utils::DEVICE_HETERO, {{ov::device::priorities.name(), ov::test::utils::DEVICE_CPU}}}, }; const Params paramsStreams[] = { diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp index a5d283cbd185e3..552f514f594819 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp @@ -10,11 +10,6 @@ namespace { ::testing::Values(ov::test::utils::DEVICE_CPU), OVHoldersTest::getTestCaseName); - INSTANTIATE_TEST_SUITE_P(smoke_VirtualPlugin_BehaviorTests, OVHoldersTest, - ::testing::Values(//ov::test::utils::DEVICE_BATCH, - "HETERO:CPU"), - OVHoldersTest::getTestCaseName); - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVHoldersTestOnImportedNetwork, ::testing::Values(ov::test::utils::DEVICE_CPU), OVHoldersTestOnImportedNetwork::getTestCaseName); diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp index ab6b3580fc7c44..7dcc98a2c63446 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp @@ -84,20 +84,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, // OV Class GetMetric // -INSTANTIATE_TEST_SUITE_P(smoke_HeteroOVGetMetricPropsTest, - OVGetMetricPropsTest, - ::testing::Values("HETERO")); - INSTANTIATE_TEST_SUITE_P(smoke_OVGetMetricPropsTest, OVGetMetricPropsTest, ::testing::Values("CPU")); -INSTANTIATE_TEST_SUITE_P( - smoke_HeteroOVCheckGetSupportedROMetricsPropsTests, - OVCheckGetSupportedROMetricsPropsTests, - ::testing::Combine(::testing::Values("HETERO"), - ::testing::ValuesIn(OVCheckGetSupportedROMetricsPropsTests::configureProperties( - {ov::device::full_name.name()}))), - OVCheckGetSupportedROMetricsPropsTests::getTestCaseName); - INSTANTIATE_TEST_SUITE_P( smoke_OVCheckGetSupportedROMetricsPropsTests, OVCheckGetSupportedROMetricsPropsTests, @@ -110,13 +98,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_OVGetAvailableDevicesPropsTest, OVGetAvailableDevicesPropsTest, ::testing::Values("CPU")); -const std::vector multiConfigs = {{ov::device::priorities(ov::test::utils::DEVICE_CPU)}}; - -INSTANTIATE_TEST_SUITE_P(smoke_OVClassSetDevicePriorityConfigPropsTest, - OVClassSetDevicePriorityConfigPropsTest, - ::testing::Combine(::testing::Values("HETERO"), - ::testing::ValuesIn(multiConfigs))); - const std::vector configsDeviceProperties = { {ov::device::properties("CPU", ov::num_streams(2))}, {ov::device::properties(ov::AnyMap{{"CPU", ov::AnyMap{ov::num_streams(2)}}})}}; diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp index aa5139d50455ca..066b6b54b862c7 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp @@ -13,11 +13,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, ::testing::Values(ov::test::utils::DEVICE_CPU), VersionTests::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, - VersionTests, - ::testing::Values(ov::test::utils::DEVICE_HETERO), - VersionTests::getTestCaseName); - } // namespace behavior } // namespace test } // namespace ov diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/memory.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/memory.cpp index 67014c9e595e9f..923ad58e932f2c 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/memory.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/memory.cpp @@ -31,7 +31,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_MemoryTest, MemoryLayerTest, ::testing::ValuesIn(iterationCount), ::testing::ValuesIn(inShapes), ::testing::ValuesIn(input_types), - ::testing::Values(ov::test::utils::DEVICE_CPU, "HETERO:CPU")), + ::testing::Values(ov::test::utils::DEVICE_CPU)), MemoryLayerTest::getTestCaseName); } // namespace diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp index 8847b4ed633146..477c6190694205 100644 --- a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp +++ b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp @@ -73,19 +73,13 @@ std::vector disabledTestPatterns() { R"(.*Behavior.*OVCompiledModelBaseTest.*canSetConfigToCompiledModel.*)", R"(.*Behavior.*OVCompiledModelBaseTest.*canExportModel.*)", R"(.*Behavior.*OVCompiledModelBaseTest.*canSetConfigToCompiledModelWithIncorrectConfig.*)", - R"(.*Hetero.*Behavior.*OVCompiledModelBaseTest.*ExecGraphInfo.*)", - R"(.*Hetero.*Behavior.*OVCompiledModelBaseTest.*canCreateTwoCompiledModelAndCheckTheir.*)", // CPU does not support dynamic rank // Issue: 66778 R"(.*smoke_BehaviorTests.*InferFullyDynamicNetworkWith(S|G)etTensor.*)", - R"(.*smoke_Hetero_BehaviorTests.*InferFullyDynamicNetworkWith(S|G)etTensor.*)", R"(.*smoke_BehaviorTests.*DynamicOutputToDynamicInput.*)", R"(.*smoke_BehaviorTests.*DynamicInputToDynamicOutput.*)", - R"(.*smoke_Hetero_BehaviorTests.*DynamicOutputToDynamicInput.*)", - R"(.*smoke_Hetero_BehaviorTests.*DynamicInputToDynamicOutput.*)", // unsupported metrics R"(.*OVGetMetricPropsTest.*OVGetMetricPropsTest.*(MAX_BATCH_SIZE).*)", - R"(.*smoke_HeteroOVGetMetricPropsTest.*OVGetMetricPropsTest.*(AVAILABLE_DEVICES|OPTIMIZATION_CAPABILITIES|RANGE_FOR_ASYNC_INFER_REQUESTS|RANGE_FOR_STREAMS).*)", // supports only '' as device id R"(.*OVClassQueryModelTest.*QueryModelWithDeviceID.*)", // Issue 67214 @@ -170,8 +164,6 @@ std::vector disabledTestPatterns() { // Issue: 114765 R"(.*smoke_PSROIPoolingAverageLayoutTest/PSROIPoolingLayerCPUTest.*bf16.*)", R"(.*smoke_PSROIPoolingBilinearLayoutTest/PSROIPoolingLayerCPUTest.*bf16.*)", - // TODO: for 22.2 (CVS-68949) - R"(.*smoke_AutoBatching_CPU/AutoBatching_Test_DetectionOutput.*)", // Issue: 120222 R"(.*smoke_TopK/TopKLayerTest.Inference.*_k=1_axis=3_.*_modelType=f16_trgDev=CPU.*)", R"(.*smoke_TopK/TopKLayerTest.Inference.*_k=7_axis=3_.*_modelType=f16_trgDev=CPU.*)", @@ -324,7 +316,6 @@ std::vector disabledTestPatterns() { #if defined(OPENVINO_ARCH_X86) retVector.emplace_back(R"(.*DetectionOutputLayerTest.*)"); // WIP: plugin cannot be loaded for some reason - retVector.emplace_back(R"(.*HeteroSyntheticTest.*)"); retVector.emplace_back(R"(.*IEClassBasicTestP.*)"); #elif defined(OPENVINO_ARCH_ARM64) || defined(OPENVINO_ARCH_ARM) { @@ -596,7 +587,6 @@ std::vector disabledTestPatterns() { retVector.emplace_back(R"(.*smoke_GatherCompressedWeights_basic/GatherWeightsDecompression.CompareWithRefs.*INFERENCE_PRECISION_HINT.*bf16.*)"); retVector.emplace_back(R"(.*smoke_Interaction/IntertactionCPUTest.CompareWithRefs.*Prc=i32.*)"); retVector.emplace_back(R"(.*smoke_MatMulCompressedWeights_(amx|sym_amx|corner_cases_amx)/MatmulWeightsDecompression.CompareWithRefs.*INFERENCE_PRECISION_HINT.*bf16.*)"); - retVector.emplace_back(R"(.*smoke_AutoBatching_CPU/AutoBatching_Test.*)"); retVector.emplace_back(R"(.*smoke_Snippets_EnforcePrecision_bf16/EnforcePrecisionTest.*)"); retVector.emplace_back(R"(.*smoke_Snippets_MHABF16_4D/MHA.CompareWithRefImpl/.*\[1.58.16.34\]_IS\[1\]=\[1.58.16.34\]_IS\[2\]=\[1.1.1.58\]_IS\[3\]=\[1.58.16.34\].*)"); retVector.emplace_back(R"(.*smoke_Snippets_MHAWOTransposeBF16_(3|4)D/MHAWOTranspose.*)"); diff --git a/src/plugins/intel_gpu/tests/functional/dynamic_tests/gpu_dyn_batch_shape_tests.cpp b/src/plugins/intel_gpu/tests/functional/dynamic_tests/gpu_dyn_batch_shape_tests.cpp index 700dfeacc95847..ed6db10b284f36 100644 --- a/src/plugins/intel_gpu/tests/functional/dynamic_tests/gpu_dyn_batch_shape_tests.cpp +++ b/src/plugins/intel_gpu/tests/functional/dynamic_tests/gpu_dyn_batch_shape_tests.cpp @@ -116,10 +116,6 @@ auto config = []() { return ov::AnyMap{}; }; -auto hetero_config = []() { - return ov::AnyMap{{ov::device::priorities.name(), ov::test::utils::DEVICE_GPU}}; -}; - const std::vector input_shapes = { { { {1, 19}, 4, 20, 20}, { {1, 4, 20, 20}, {7, 4, 20, 20}, {17, 4, 20, 20} } } }; @@ -136,12 +132,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_GPU_DynBatch, OVDynamicBatchShape_Tests, ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::Values(config())), OVDynamicBatchShape_Tests::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_GPU_DynBatchHetero, OVDynamicBatchShape_Tests, - ::testing::Combine( - ::testing::Values(input_shapes), - ::testing::ValuesIn(model_types), - ::testing::Values(ov::test::utils::DEVICE_HETERO), - ::testing::Values(hetero_config())), - OVDynamicBatchShape_Tests::getTestCaseName); } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_executable_network/exec_net_base.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_executable_network/exec_net_base.cpp index e314a6548ce380..c7938b44ef6efd 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_executable_network/exec_net_base.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_executable_network/exec_net_base.cpp @@ -12,27 +12,12 @@ auto configs = []() { }; }; -auto autoBatchConfigs = []() { - return std::vector{ - // explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU) - {{ov::device::priorities.name(), std::string(ov::test::utils::DEVICE_GPU) + "(4)"}, - // no timeout to avoid increasing the test time - ov::auto_batch_timeout(0)}}; -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVCompiledModelBaseTest, ::testing::Combine( ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(configs())), OVCompiledModelBaseTest::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatchBehaviorTests, OVCompiledModelBaseTest, - ::testing::Combine( - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(autoBatchConfigs())), - OVCompiledModelBaseTest::getTestCaseName); - - std::vector convert_types = {ov::element::f16, ov::element::i64}; @@ -42,11 +27,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, CompiledModelSetType, ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(configs())), CompiledModelSetType::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatchBehaviorTests, CompiledModelSetType, - ::testing::Combine( - ::testing::ValuesIn(convert_types), - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(autoBatchConfigs())), - CompiledModelSetType::getTestCaseName); } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_executable_network/get_metric.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_executable_network/get_metric.cpp index bb3a686d951181..86f017c0ea6feb 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_executable_network/get_metric.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_executable_network/get_metric.cpp @@ -20,13 +20,12 @@ using ov::test::behavior::OVCompiledModelIncorrectDevice; // INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetPropertyTest, OVClassCompiledModelGetPropertyTest, - ::testing::Values("GPU", "HETERO:GPU", "BATCH:GPU")); + ::testing::Values("GPU")); const std::vector>> GetMetricTest_ExecutionDevice_GPU = { {"GPU", std::make_pair(ov::AnyMap{}, "GPU.0")}, - {"GPU.0", std::make_pair(ov::AnyMap{}, "GPU.0")}, - {"BATCH:GPU", std::make_pair(ov::AnyMap{}, "GPU.0")}}; + {"GPU.0", std::make_pair(ov::AnyMap{}, "GPU.0")}}; INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetPropertyTest, OVClassCompiledModelGetPropertyTest_EXEC_DEVICES, @@ -38,7 +37,7 @@ INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetPropertyTest, // INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetIncorrectPropertyTest, OVClassCompiledModelGetIncorrectPropertyTest, - ::testing::Values("GPU", "HETERO:GPU", "BATCH:GPU")); + ::testing::Values("GPU")); INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelGetConfigTest, OVClassCompiledModelGetConfigTest, @@ -52,19 +51,6 @@ INSTANTIATE_TEST_SUITE_P(nightly_OVClassCompiledModelSetIncorrectConfigTest, // OV Class Load network INSTANTIATE_TEST_SUITE_P(smoke_OVCompiledModelIncorrectDevice, OVCompiledModelIncorrectDevice, ::testing::Values("GPU")); -const std::vector incorrect_device_priorities_properties = {{ov::device::priorities("NONE")}, - {ov::device::priorities("NONE", "GPU")}, - {ov::device::priorities("-", "GPU")}, - {ov::device::priorities("-NONE", "CPU")}, - {ov::device::priorities("-CPU", "-NONE")}, - {ov::device::priorities("-NONE", "-NONE")}}; - -INSTANTIATE_TEST_SUITE_P(smoke_BehaviorIncorrectPropertiesTests, - OVClassCompiledModelPropertiesIncorrectTests, - ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_HETERO), - ::testing::ValuesIn(incorrect_device_priorities_properties)), - OVClassCompiledModelPropertiesIncorrectTests::getTestCaseName); - const std::vector gpuCorrectConfigs = { {ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT), ov::hint::allow_auto_batching(false)}, {ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT), ov::hint::allow_auto_batching(true)}}; @@ -95,15 +81,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_OVClassCompileModelWithCorrectSecondaryProperties ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(gpuCorrectConfigsWithSecondaryProperties())), ::testing::PrintToStringParamName()); - -INSTANTIATE_TEST_SUITE_P(smoke_HETERO_OVClassCompileModelWithCorrectSecondaryPropertiesTest, - OVClassCompileModelWithCorrectPropertiesTest, - ::testing::Combine(::testing::Values("HETERO:GPU"), - ::testing::ValuesIn(gpuCorrectConfigsWithSecondaryProperties()))); - -const std::vector batchCorrectConfigs = {{}}; - -INSTANTIATE_TEST_SUITE_P(smoke_Auto_Batch_OVClassCompileModelWithCorrectPropertiesAutoBatchingTest, - OVClassCompileModelWithCorrectPropertiesTest, - ::testing::Combine(::testing::Values("BATCH:GPU"), ::testing::ValuesIn(batchCorrectConfigs))); } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/callback.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/callback.cpp index 6e2945ad5906dc..63d01791479cf6 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/callback.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/callback.cpp @@ -17,23 +17,10 @@ auto configs = []() { }; }; -auto autoBatchConfigs = []() { - return std::vector{// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU) - {ov::device::priorities(std::string(ov::test::utils::DEVICE_GPU) + "(4)"), - // no timeout to avoid increasing the test time - ov::auto_batch_timeout(0)}}; -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestCallbackTests, ::testing::Combine( ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(configs())), OVInferRequestCallbackTests::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestCallbackTests, - ::testing::Combine( - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(autoBatchConfigs())), - OVInferRequestCallbackTests::getTestCaseName); - } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/cancellation.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/cancellation.cpp index b468028fa26047..a8aea4904f2d0f 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/cancellation.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/cancellation.cpp @@ -13,22 +13,9 @@ auto configs = []() { }; }; -auto autoBatchConfigs = []() { - return std::vector{// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU) - {ov::device::priorities(std::string(ov::test::utils::DEVICE_GPU) + "(4)"), - // no timeout to avoid increasing the test time - ov::auto_batch_timeout(0)}}; -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestCancellationTests, ::testing::Combine( ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(configs())), OVInferRequestCancellationTests::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatchBehaviorTests, OVInferRequestCancellationTests, - ::testing::Combine( - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(autoBatchConfigs())), - OVInferRequestCancellationTests::getTestCaseName); } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/io_tensor.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/io_tensor.cpp index a9abd7571bf5f5..10d5df4dc19fbe 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/io_tensor.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/io_tensor.cpp @@ -22,26 +22,12 @@ auto configs = []() { }; }; -auto AutoBatchConfigs = []() { - return std::vector{ - // explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU) - {{ov::device::priorities.name(), std::string(ov::test::utils::DEVICE_GPU) + "(4)"}, - // no timeout to avoid increasing the test time - ov::auto_batch_timeout(0)}}; -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestIOTensorTest, ::testing::Combine( ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(configs())), OVInferRequestIOTensorTest::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestIOTensorTest, - ::testing::Combine( - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(AutoBatchConfigs())), - OVInferRequestIOTensorTest::getTestCaseName); - std::vector prcs = { ov::element::boolean, ov::element::bf16, @@ -83,24 +69,10 @@ INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestIOTensorSetPrecision ::testing::ValuesIn(configs())), OVInferRequestIOTensorSetPrecisionTest::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestIOTensorSetPrecisionTest, - ::testing::Combine( - ::testing::ValuesIn(prcs), - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(AutoBatchConfigs())), - OVInferRequestIOTensorSetPrecisionTest::getTestCaseName); - INSTANTIATE_TEST_SUITE_P(smoke_GPU_BehaviorTests, OVInferRequestCheckTensorPrecision, ::testing::Combine( ::testing::ValuesIn(supported_input_prcs), ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(emptyConfigs())), OVInferRequestCheckTensorPrecision::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestCheckTensorPrecision, - ::testing::Combine( - ::testing::ValuesIn(supported_input_prcs), - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(AutoBatchConfigs())), - OVInferRequestCheckTensorPrecision::getTestCaseName); } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/multithreading.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/multithreading.cpp index d8af4f11cfa796..85723dcb73098d 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/multithreading.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/multithreading.cpp @@ -17,22 +17,9 @@ auto configs = []() { }; }; -auto AutoBatchConfigs = []() { - return std::vector{// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU) - {ov::device::priorities(std::string(ov::test::utils::DEVICE_GPU) + "(4)"), - // no timeout to avoid increasing the test time - ov::auto_batch_timeout(0)}}; -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestMultithreadingTests, ::testing::Combine( ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(configs())), OVInferRequestMultithreadingTests::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestMultithreadingTests, - ::testing::Combine( - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(AutoBatchConfigs())), - OVInferRequestMultithreadingTests::getTestCaseName); } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/perf_counters.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/perf_counters.cpp index 114123f1a58853..5fef3449a71b13 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/perf_counters.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/perf_counters.cpp @@ -11,22 +11,9 @@ auto configs = []() { return std::vector{{}}; }; -auto AutoBatchConfigs = []() { - return std::vector{// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU) - {ov::device::priorities(std::string(ov::test::utils::DEVICE_GPU) + "(4)"), - // no timeout to avoid increasing the test time - ov::auto_batch_timeout(0)}}; -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestPerfCountersTest, ::testing::Combine( ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(configs())), OVInferRequestPerfCountersTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestPerfCountersTest, - ::testing::Combine( - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(AutoBatchConfigs())), - OVInferRequestPerfCountersTest::getTestCaseName); } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/wait.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/wait.cpp index a465a6bb21e371..237c400747ff61 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/wait.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_infer_request/wait.cpp @@ -17,22 +17,9 @@ auto configs = []() { }; }; -auto AutoBatchConfigs = []() { - return std::vector{// explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU) - {ov::device::priorities(std::string(ov::test::utils::DEVICE_GPU) + "(4)"), - // no timeout to avoid increasing the test time - ov::auto_batch_timeout(0)}}; -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestWaitTests, ::testing::Combine( ::testing::Values(ov::test::utils::DEVICE_GPU), ::testing::ValuesIn(configs())), OVInferRequestWaitTests::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_AutoBatch_BehaviorTests, OVInferRequestWaitTests, - ::testing::Combine( - ::testing::Values(ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(AutoBatchConfigs())), - OVInferRequestWaitTests::getTestCaseName); } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp index 65c2e7b5e86015..6cffa55b714de4 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/life_time.cpp @@ -10,11 +10,6 @@ namespace { ::testing::Values(ov::test::utils::DEVICE_GPU), OVHoldersTest::getTestCaseName); - INSTANTIATE_TEST_SUITE_P(smoke_VirtualPlugin_BehaviorTests, OVHoldersTest, - ::testing::Values(//ov::test::utils::DEVICE_BATCH, - "HETERO:GPU"), - OVHoldersTest::getTestCaseName); - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVHoldersTestOnImportedNetwork, ::testing::Values(ov::test::utils::DEVICE_GPU), OVHoldersTestOnImportedNetwork::getTestCaseName); diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp index 7e28a9b23c6a4d..e502636c36e8df 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/properties_tests.cpp @@ -50,10 +50,6 @@ INSTANTIATE_TEST_SUITE_P(nightly_OVClassCommon, // // OV Class GetMetric // // -INSTANTIATE_TEST_SUITE_P(nightly_HeteroAutoBatchOVGetMetricPropsTest, - OVGetMetricPropsTest, - ::testing::Values("HETERO", "BATCH")); - INSTANTIATE_TEST_SUITE_P(nightly_gpuOVGetMetricPropsTest, OVGetMetricPropsTest, ::testing::Values("GPU")); INSTANTIATE_TEST_SUITE_P(nightly_OVGetAvailableDevicesPropsTest, @@ -82,17 +78,6 @@ INSTANTIATE_TEST_SUITE_P( {ov::hint::execution_mode.name()}))), OVCheckSetSupportedRWMetricsPropsTests::getTestCaseName); -auto multiConfigs = []() { - return std::vector{ - {ov::device::priorities(ov::test::utils::DEVICE_CPU)}, - {ov::device::priorities(ov::test::utils::DEVICE_GPU)}, - }; -}; - -INSTANTIATE_TEST_SUITE_P(smoke_OVClassSetDevicePriorityConfigPropsTest, - OVClassSetDevicePriorityConfigPropsTest, - ::testing::Combine(::testing::Values("HETERO"), - ::testing::ValuesIn(multiConfigs()))); // // GPU specific metrics // diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/remote.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/remote.cpp index c6806642753e10..7267cad9c481f2 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/remote.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/remote.cpp @@ -15,14 +15,6 @@ std::vector> generate_remote_params() { return {}; } -auto AutoBatchConfigs = []() { - return std::vector{ - // explicit batch size 4 to avoid fallback to no auto-batching (i.e. plain GPU) - {{ov::device::priorities.name(), std::string(ov::test::utils::DEVICE_GPU) + "(4)"}, - // no timeout to avoid increasing the test time - {ov::auto_batch_timeout.name(), "0 "}}}; -}; - INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_BehaviorTests, OVRemoteTest, ::testing::Combine( ::testing::Values(ov::element::f32), @@ -30,12 +22,4 @@ INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_BehaviorTests, OVRemoteTest, ::testing::ValuesIn(configs), ::testing::ValuesIn(generate_remote_params())), OVRemoteTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(DISABLED_smoke_AutoBatch_BehaviorTests, OVRemoteTest, - ::testing::Combine( - ::testing::Values(ov::element::f32), - ::testing::Values(::ov::test::utils::DEVICE_BATCH), - ::testing::ValuesIn(AutoBatchConfigs()), - ::testing::ValuesIn(generate_remote_params())), - OVRemoteTest::getTestCaseName); } // namespace diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp index 62a3f8e16844ea..81c282b14a27cc 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/behavior/ov_plugin/version.cpp @@ -13,11 +13,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, ::testing::Values(ov::test::utils::DEVICE_GPU), VersionTests::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, - VersionTests, - ::testing::Values(ov::test::utils::DEVICE_HETERO), - VersionTests::getTestCaseName); - } // namespace behavior } // namespace test } // namespace ov diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/skip_tests_config.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/skip_tests_config.cpp index 45005d6ebf93cd..321ec262b5b2da 100644 --- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/skip_tests_config.cpp +++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/skip_tests_config.cpp @@ -27,7 +27,6 @@ std::vector disabledTestPatterns() { R"(.*(ProposalLayerTest).*)", // TODO: Issue: 54194 R"(.*ActivationLayerTest.*SoftPlus.*)", - R"(.*Behavior.*InferRequestSetBlobByType.*Device=HETERO.*)", // TODO: Issue: 59586, NormalizeL2 output mismatch for empty axes case R"(.*NormalizeL2LayerTest.*axes=\(\).*)", @@ -58,13 +57,10 @@ std::vector disabledTestPatterns() { // Assign-3/ReadValue-3 does not have evaluate() methods; ref implementation does not save the value across the inferences. R"(smoke_MemoryTestV3.*)", // Issue: 90539 - R"(smoke_AutoBatch_BehaviorTests/OVInferRequestIOTensorTest.InferStaticNetworkSetInputTensor/targetDevice=BATCH.*)", R"(.*CachingSupportCase.*LoadNetworkCacheTestBase.*CompareWithRefImpl.*)", // Issue: 119648 R"(.*smoke_LPT/InterpolateTransformation.*)", R"(.*CachingSupportCase.*GPU.*CompileModelCacheTestBase.*CompareWithRefImpl.*)", - // unsupported metrics - R"(.*nightly_HeteroAutoBatchOVGetMetricPropsTest.*OVGetMetricPropsTest.*(FULL_DEVICE_NAME_with_DEVICE_ID|AVAILABLE_DEVICES|DEVICE_UUID|OPTIMIZATION_CAPABILITIES|MAX_BATCH_SIZE|DEVICE_GOPS|DEVICE_TYPE|RANGE_FOR_ASYNC_INFER_REQUESTS|RANGE_FOR_STREAMS).*)", // Issue: 111437 R"(.*smoke_Deconv_2D_Dynamic_.*FP32/DeconvolutionLayerGPUTest.Inference.*)", R"(.*smoke_GroupDeconv_2D_Dynamic_.*FP32/GroupDeconvolutionLayerGPUTest.Inference.*)",