diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/CMakeLists.txt b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/CMakeLists.txt index 5215943d193..3826a6e6242 100644 --- a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/CMakeLists.txt +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/CMakeLists.txt @@ -10,6 +10,9 @@ addIeTargetTest( ADDITIONAL_SOURCE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/src ADD_CPPLINT + INCLUDES + PRIVATE + "${CMAKE_CURRENT_SOURCE_DIR}/include" LINK_LIBRARIES PUBLIC conformanceShared diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/include/api_conformance_helpers.hpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/include/api_conformance_helpers.hpp new file mode 100644 index 00000000000..36dc38cf3e9 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/include/api_conformance_helpers.hpp @@ -0,0 +1,86 @@ +// Copyright (C) 2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include "conformance.hpp" +#include "common_test_utils/test_constants.hpp" + +// TODO: fix namespaces +using namespace ConformanceTests; + +namespace ov { +namespace test { +namespace conformance { + +inline const std::string getPluginLibNameByDevice(const std::string& deviceName) { + const std::map devices{ + { "AUTO", "AutoPlugin" }, + { "HDDL", "HDDLPlugin" }, + { "VPUX", "VPUXPlugin" }, + { "AUTO", "MultiDevicePlugin" }, + { "CPU", "MKLDNNPlugin" }, + { "GNA", "GNAPlugin" }, + { "GPU", "clDNNPlugin" }, + { "HETERO", "HeteroPlugin" }, + { "MULTI", "MultiDevicePlugin" }, + { "MYRIAD", "myriadPlugin" }, + { "TEMPLATE", "templatePlugin" }, + }; + if (devices.find(deviceName) == devices.end()) { + throw std::runtime_error("Incorrect device name"); + } + return devices.at(deviceName); +} + +inline const std::pair generateDefaultMultiConfig() { + return {MULTI_CONFIG_KEY(DEVICE_PRIORITIES), ConformanceTests::targetDevice}; +} + +inline const std::pair generateDefaultHeteroConfig() { + return { "TARGET_FALLBACK" , ConformanceTests::targetDevice }; +} + +inline const std::vector> generateConfigs(const std::string& targetDevice, + const std::vector>& config = {}) { + std::pair defaultConfig; + if (targetDevice == std::string(CommonTestUtils::DEVICE_MULTI) || targetDevice == std::string(CommonTestUtils::DEVICE_AUTO)) { + defaultConfig = generateDefaultMultiConfig(); + } else if (targetDevice == std::string(CommonTestUtils::DEVICE_HETERO)) { + defaultConfig = generateDefaultHeteroConfig(); + } else { + throw std::runtime_error("Incorrect target device: " + targetDevice); + } + + std::vector> resultConfig; + if (config.empty()) { + return {{defaultConfig}}; + } + for (auto configItem : config) { + configItem.insert(defaultConfig); + resultConfig.push_back(configItem); + } + return resultConfig; +} + +inline const std::string generateComplexDeviceName(const std::string& deviceName) { + return deviceName + ":" + ConformanceTests::targetDevice; +} + +inline const std::vector returnAllPossibleDeviceCombination() { + std::vector res{ConformanceTests::targetDevice}; + std::vector devices{CommonTestUtils::DEVICE_HETERO, CommonTestUtils::DEVICE_AUTO, CommonTestUtils::DEVICE_MULTI}; + for (const auto& device : devices) { + res.emplace_back(generateComplexDeviceName(device)); + } + return res; +} + +const std::vector> emptyConfig = { + {}, +}; + +} // namespace conformance +} // namespace test +} // namespace ov \ No newline at end of file diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/caching/caching_tests.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/caching/caching_tests.cpp new file mode 100644 index 00000000000..b2820892a3c --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/caching/caching_tests.cpp @@ -0,0 +1,40 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/caching/caching_tests.hpp" +#include +#include +#include "conformance.hpp" + +namespace { +using namespace LayerTestsDefinitions; +using namespace ngraph; + +static const std::vector precisionsTemplate = { + ov::element::f64, + ov::element::f32, + ov::element::f16, + ov::element::i64, + ov::element::i32, + ov::element::i16, + ov::element::i8, + ov::element::u64, + ov::element::u32, + ov::element::u16, + ov::element::u8, + ov::element::boolean, +}; + +static const std::vector batchSizesTemplate = { + 1, 2 +}; + +INSTANTIATE_TEST_SUITE_P(smoke_Behavior_CachingSupportCase, LoadNetworkCacheTestBase, + ::testing::Combine( + ::testing::ValuesIn(LoadNetworkCacheTestBase::getStandardFunctions()), + ::testing::ValuesIn(precisionsTemplate), + ::testing::ValuesIn(batchSizesTemplate), + ::testing::Values(ConformanceTests::targetDevice)), + LoadNetworkCacheTestBase::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/exec_graph_info.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/exec_graph_info.cpp new file mode 100644 index 00000000000..a9a72041afa --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/exec_graph_info.cpp @@ -0,0 +1,29 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include +#include +#include "behavior/executable_network/exec_graph_info.hpp" +#include "api_conformance_helpers.hpp" + +namespace { +using namespace ExecutionGraphTests; + +INSTANTIATE_TEST_SUITE_P(smoke_serialization, ExecGraphSerializationTest, + ::testing::Values(ConformanceTests::targetDevice), + ExecGraphSerializationTest::getTestCaseName); + +const std::vector execGraphInfoElemTypes = { + InferenceEngine::Precision::FP32 +}; + +INSTANTIATE_TEST_SUITE_P(smoke_NoReshape, ExecGraphUniqueNodeNames, + ::testing::Combine( + ::testing::ValuesIn(execGraphInfoElemTypes), + ::testing::Values(InferenceEngine::SizeVector({1, 2, 5, 5})), + ::testing::Values(ConformanceTests::targetDevice)), + ExecGraphUniqueNodeNames::getTestCaseName); + +} // namespace + diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/exec_network_base.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/exec_network_base.cpp new file mode 100644 index 00000000000..77417c3e207 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/exec_network_base.cpp @@ -0,0 +1,66 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/executable_network/exec_network_base.hpp" +#include "ie_plugin_config.hpp" + +#include "api_conformance_helpers.hpp" + +using namespace BehaviorTestsDefinitions; +using namespace ov::test::conformance; + +namespace { + INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, ExecutableNetworkBaseTest, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + ExecutableNetworkBaseTest::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, ExecutableNetworkBaseTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + ExecutableNetworkBaseTest::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, ExecutableNetworkBaseTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + ExecutableNetworkBaseTest::getTestCaseName); + + const std::vector execNetBaseElemTypes = { + InferenceEngine::Precision::FP32, + InferenceEngine::Precision::U8, + InferenceEngine::Precision::I16, + InferenceEngine::Precision::U16 + }; + + INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, ExecNetSetPrecision, + ::testing::Combine( + ::testing::ValuesIn(execNetBaseElemTypes), + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + ExecNetSetPrecision::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, ExecNetSetPrecision, + ::testing::Combine( + ::testing::ValuesIn(execNetBaseElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + ExecNetSetPrecision::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, ExecNetSetPrecision, + ::testing::Combine( + ::testing::ValuesIn(execNetBaseElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + ExecNetSetPrecision::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, ExecNetSetPrecision, + ::testing::Combine( + ::testing::ValuesIn(execNetBaseElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + ExecNetSetPrecision::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/get_metric.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/get_metric.cpp new file mode 100644 index 00000000000..40a4d413934 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/get_metric.cpp @@ -0,0 +1,74 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/executable_network/get_metric.hpp" +#include "api_conformance_helpers.hpp" + +using namespace ov::test::conformance; +using namespace BehaviorTestsDefinitions; +using namespace InferenceEngine::PluginConfigParams; + +namespace { + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassImportExportTestP, IEClassImportExportTestP, + ::testing::Values(generateComplexDeviceName(CommonTestUtils::DEVICE_HETERO))); + +// +// Executable Network GetMetric +// + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassExecutableNetworkGetMetricTest, IEClassExecutableNetworkGetMetricTest_SUPPORTED_CONFIG_KEYS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassExecutableNetworkGetMetricTest, IEClassExecutableNetworkGetMetricTest_SUPPORTED_METRICS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassExecutableNetworkGetMetricTest, IEClassExecutableNetworkGetMetricTest_NETWORK_NAME, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassExecutableNetworkGetMetricTest, IEClassExecutableNetworkGetMetricTest_OPTIMAL_NUMBER_OF_INFER_REQUESTS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassExecutableNetworkGetMetricTest, IEClassExecutableNetworkGetMetricTest_ThrowsUnsupported, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +// +// Executable Network GetConfig / SetConfig +// + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassExecutableNetworkGetConfigTest, IEClassExecutableNetworkGetConfigTest, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassExecutableNetworkSetConfigTest, IEClassExecutableNetworkSetConfigTest, + ::testing::Values(ConformanceTests::targetDevice)); + +// +// Hetero Executable Network GetMetric +// + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassHeteroExecutableNetworkGetMetricTest, IEClassHeteroExecutableNetworkGetMetricTest_SUPPORTED_CONFIG_KEYS, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassHeteroExecutableNetworkGetMetricTest, IEClassHeteroExecutableNetworkGetMetricTest_SUPPORTED_METRICS, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassHeteroExecutableNetworkGetMetricTest, IEClassHeteroExecutableNetworkGetMetricTest_NETWORK_NAME, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassHeteroExecutableNetworkGetMetricTest, IEClassHeteroExecutableNetworkGetMetricTest_TARGET_FALLBACK, + ::testing::Values(ConformanceTests::targetDevice)); + +} // namespace \ No newline at end of file diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/callback.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/callback.cpp index 871b5a59bd8..7137300df77 100644 --- a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/callback.cpp +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/callback.cpp @@ -3,39 +3,34 @@ // #include "behavior/infer_request/callback.hpp" -#include "conformance.hpp" +#include "api_conformance_helpers.hpp" namespace { +using namespace ov::test::conformance; using namespace BehaviorTestsDefinitions; using namespace ConformanceTests; -const std::vector> configsCallback = { - {}, -}; - -const std::vector> multiConfigsCallback = { - {{MULTI_CONFIG_KEY(DEVICE_PRIORITIES), targetDevice}} -}; - -const std::vector> autoConfigsCallback = { - {{MULTI_CONFIG_KEY(DEVICE_PRIORITIES), targetDevice}} -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestCallbackTests, ::testing::Combine( ::testing::Values(targetDevice), - ::testing::ValuesIn(configsCallback)), + ::testing::ValuesIn(emptyConfig)), InferRequestCallbackTests::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, InferRequestCallbackTests, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_MULTI), - ::testing::ValuesIn(multiConfigsCallback)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), InferRequestCallbackTests::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestCallbackTests, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_AUTO), - ::testing::ValuesIn(autoConfigsCallback)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + InferRequestCallbackTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, InferRequestCallbackTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), InferRequestCallbackTests::getTestCaseName); } // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/cancellation.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/cancellation.cpp index 49a1dbc904d..75cdcdd658a 100644 --- a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/cancellation.cpp +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/cancellation.cpp @@ -3,19 +3,16 @@ // #include "behavior/infer_request/cancellation.hpp" -#include "conformance.hpp" +#include "api_conformance_helpers.hpp" namespace { using namespace BehaviorTestsDefinitions; using namespace ConformanceTests; - -const std::vector> configsCancel = { - {}, -}; +using namespace ov::test::conformance; INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestCancellationTests, ::testing::Combine( ::testing::Values(targetDevice), - ::testing::ValuesIn(configsCancel)), + ::testing::ValuesIn(emptyConfig)), InferRequestCancellationTests::getTestCaseName); } // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/io_blob.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/io_blob.cpp index 37cc8246e7b..21d7dcc0c86 100644 --- a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/io_blob.cpp +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/io_blob.cpp @@ -6,39 +6,34 @@ #include "behavior/infer_request/io_blob.hpp" #include "ie_plugin_config.hpp" -#include "conformance.hpp" +#include "api_conformance_helpers.hpp" namespace { +using namespace ov::test::conformance; using namespace BehaviorTestsDefinitions; using namespace ConformanceTests; -const std::vector> configsIOBlob = { - {}, -}; - -const std::vector> MulticonfigsIOBlob = { - {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES), targetDevice }} -}; - -const std::vector> AutoconfigsIOBlob = { - {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES), targetDevice}} -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestIOBBlobTest, ::testing::Combine( ::testing::Values(targetDevice), - ::testing::ValuesIn(configsIOBlob)), + ::testing::ValuesIn(emptyConfig)), InferRequestIOBBlobTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, InferRequestIOBBlobTest, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_MULTI), - ::testing::ValuesIn(MulticonfigsIOBlob)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), InferRequestIOBBlobTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestIOBBlobTest, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_AUTO), - ::testing::ValuesIn(AutoconfigsIOBlob)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + InferRequestIOBBlobTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, InferRequestIOBBlobTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), InferRequestIOBBlobTest::getTestCaseName); } // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/multitheading.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/multitheading.cpp index f921b4311b9..ea24706a8df 100644 --- a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/multitheading.cpp +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/multitheading.cpp @@ -7,41 +7,35 @@ #include "behavior/infer_request/multithreading.hpp" #include "ie_plugin_config.hpp" -#include "conformance.hpp" +#include "api_conformance_helpers.hpp" namespace { - +using namespace ov::test::conformance; using namespace ConformanceTests; using namespace BehaviorTestsDefinitions; -const std::vector> configsMultithreading = { - {}, -}; - -const std::vector> MulticonfigsMultithreading = { - {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES), targetDevice }} -}; - -const std::vector> AutoconfigsMultithreading = { - {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES), targetDevice}} -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestMultithreadingTests, ::testing::Combine( ::testing::Values(targetDevice), - ::testing::ValuesIn(configsMultithreading)), + ::testing::ValuesIn(emptyConfig)), InferRequestMultithreadingTests::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, InferRequestMultithreadingTests, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_MULTI), - ::testing::ValuesIn(MulticonfigsMultithreading)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), InferRequestMultithreadingTests::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestMultithreadingTests, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_AUTO), - ::testing::ValuesIn(AutoconfigsMultithreading)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + InferRequestMultithreadingTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, InferRequestMultithreadingTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), InferRequestMultithreadingTests::getTestCaseName); } // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/perf_counters.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/perf_counters.cpp index a7bfe68707c..d5cfcbcbde3 100644 --- a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/perf_counters.cpp +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/perf_counters.cpp @@ -3,41 +3,35 @@ // #include "behavior/infer_request/perf_counters.hpp" -#include "conformance.hpp" +#include "api_conformance_helpers.hpp" namespace { - +using namespace ov::test::conformance; using namespace ConformanceTests; using namespace BehaviorTestsDefinitions; -const std::vector> configsPerfCounters = { - {} -}; - -const std::vector> MulticonfigsPerfCounters = { - {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES), targetDevice }} -}; - -const std::vector> AutoconfigsPerfCounters = { - {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES), targetDevice }} -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestPerfCountersTest, ::testing::Combine( ::testing::Values(targetDevice), - ::testing::ValuesIn(configsPerfCounters)), + ::testing::ValuesIn(emptyConfig)), InferRequestPerfCountersTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, InferRequestPerfCountersTest, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_MULTI), - ::testing::ValuesIn(MulticonfigsPerfCounters)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), InferRequestPerfCountersTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestPerfCountersTest, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_AUTO), - ::testing::ValuesIn(AutoconfigsPerfCounters)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + InferRequestPerfCountersTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, InferRequestPerfCountersTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), InferRequestPerfCountersTest::getTestCaseName); diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/set_blob_by_type.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/set_blob_by_type.cpp index 55f31b42328..49a2b23bd73 100644 --- a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/set_blob_by_type.cpp +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/set_blob_by_type.cpp @@ -4,14 +4,14 @@ #include "behavior/infer_request/set_blob_by_type.hpp" #include "common_test_utils/test_constants.hpp" -#include "conformance.hpp" +#include "api_conformance_helpers.hpp" namespace { - +using namespace ov::test::conformance; using namespace ConformanceTests; using namespace BehaviorTestsDefinitions; -const std::vector BlobTypes = { +const std::vector setBlobTypes = { FuncTestUtils::BlobType::Compound, FuncTestUtils::BlobType::Batched, FuncTestUtils::BlobType::Memory, @@ -21,32 +21,29 @@ const std::vector BlobTypes = { }; const std::map ConfigBlobType{}; //nothing special -const std::map autoConfigBlobType{}; -const std::map multiConfigBlobType{{MULTI_CONFIG_KEY(DEVICE_PRIORITIES), targetDevice}}; -const std::map heteroConfigBlobType{{"TARGET_FALLBACK", targetDevice}}; INSTANTIATE_TEST_SUITE_P(smoke_Behavior, InferRequestSetBlobByType, - ::testing::Combine(::testing::ValuesIn(BlobTypes), + ::testing::Combine(::testing::ValuesIn(setBlobTypes), ::testing::Values(targetDevice), ::testing::Values(ConfigBlobType)), InferRequestSetBlobByType::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Behavior_Multi, InferRequestSetBlobByType, - ::testing::Combine(::testing::ValuesIn(BlobTypes), + ::testing::Combine(::testing::ValuesIn(setBlobTypes), ::testing::Values(CommonTestUtils::DEVICE_MULTI), - ::testing::Values(multiConfigBlobType)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), InferRequestSetBlobByType::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Behavior_Auto, InferRequestSetBlobByType, - ::testing::Combine(::testing::ValuesIn(BlobTypes), + ::testing::Combine(::testing::ValuesIn(setBlobTypes), ::testing::Values(CommonTestUtils::DEVICE_AUTO + std::string(":") + targetDevice), - ::testing::Values(autoConfigBlobType)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), InferRequestSetBlobByType::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Behavior_Hetero, InferRequestSetBlobByType, - ::testing::Combine(::testing::ValuesIn(BlobTypes), + ::testing::Combine(::testing::ValuesIn(setBlobTypes), ::testing::Values(CommonTestUtils::DEVICE_HETERO), - ::testing::Values(heteroConfigBlobType)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), InferRequestSetBlobByType::getTestCaseName); } // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/wait.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/wait.cpp index 44ee45c5a1b..e70458bdf4a 100644 --- a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/wait.cpp +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/wait.cpp @@ -6,41 +6,35 @@ #include "behavior/infer_request/wait.hpp" #include "ie_plugin_config.hpp" -#include "conformance.hpp" +#include "api_conformance_helpers.hpp" namespace { - +using namespace ov::test::conformance; using namespace ConformanceTests; using namespace BehaviorTestsDefinitions; -const std::vector> configsWait = { - {}, -}; - -const std::vector> MulticonfigsWait = { - {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , targetDevice}} -}; - -const std::vector> AutoconfigsWait = { - {{ MULTI_CONFIG_KEY(DEVICE_PRIORITIES) , targetDevice}} -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestWaitTests, ::testing::Combine( ::testing::Values(targetDevice), - ::testing::ValuesIn(configsWait)), + ::testing::ValuesIn(emptyConfig)), InferRequestWaitTests::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, InferRequestWaitTests, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_MULTI), - ::testing::ValuesIn(MulticonfigsWait)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), InferRequestWaitTests::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestWaitTests, ::testing::Combine( ::testing::Values(CommonTestUtils::DEVICE_AUTO), - ::testing::ValuesIn(AutoconfigsWait)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + InferRequestWaitTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, InferRequestWaitTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), InferRequestWaitTests::getTestCaseName); } // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_executable_network/exec_graph_info.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_executable_network/exec_graph_info.cpp new file mode 100644 index 00000000000..36df9d98958 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_executable_network/exec_graph_info.cpp @@ -0,0 +1,58 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// +#include "behavior/ov_executable_network/exec_graph_info.hpp" +#include "api_conformance_helpers.hpp" + +#include "ie_plugin_config.hpp" +#include + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { +const std::vector ovExecGraphInfoElemTypes = { + ov::element::i8, + ov::element::i16, + ov::element::i32, + ov::element::i64, + ov::element::u8, + ov::element::u16, + ov::element::u32, + ov::element::u64, + ov::element::f16, + ov::element::f32, +}; + +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, + OVExecGraphImportExportTest, + ::testing::Combine( + ::testing::ValuesIn(ovExecGraphInfoElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_CPU), + ::testing::ValuesIn(emptyConfig)), + OVExecGraphImportExportTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, + OVExecGraphImportExportTest, + ::testing::Combine( + ::testing::ValuesIn(ovExecGraphInfoElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVExecGraphImportExportTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, + OVExecGraphImportExportTest, + ::testing::Combine( + ::testing::ValuesIn(ovExecGraphInfoElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVExecGraphImportExportTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, + OVExecGraphImportExportTest, + ::testing::Combine(::testing::ValuesIn(ovExecGraphInfoElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVExecGraphImportExportTest::getTestCaseName); + +} // namespace \ No newline at end of file diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_executable_network/exec_network_base.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_executable_network/exec_network_base.cpp new file mode 100644 index 00000000000..4b25b0b84c7 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_executable_network/exec_network_base.cpp @@ -0,0 +1,36 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_executable_network/exec_network_base.hpp" +#include "ie_plugin_config.hpp" +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVExecutableNetworkBaseTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_CPU), + ::testing::ValuesIn(emptyConfig)), + OVExecutableNetworkBaseTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVExecutableNetworkBaseTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVExecutableNetworkBaseTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVExecutableNetworkBaseTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVExecutableNetworkBaseTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVExecutableNetworkBaseTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVExecutableNetworkBaseTest::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_executable_network/get_metric.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_executable_network/get_metric.cpp new file mode 100644 index 00000000000..6b3f8ead1e9 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_executable_network/get_metric.cpp @@ -0,0 +1,83 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_executable_network/get_metric.hpp" +#include "openvino/runtime/core.hpp" +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; +using namespace InferenceEngine::PluginConfigParams; + +namespace { +// +// IE Class Common tests with +// + + + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassImportExportTestP, OVClassImportExportTestP, + ::testing::Values(generateComplexDeviceName(CommonTestUtils::DEVICE_HETERO))); + +// +// Executable Network GetMetric +// + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassExecutableNetworkGetMetricTest, OVClassExecutableNetworkGetMetricTest_SUPPORTED_CONFIG_KEYS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassExecutableNetworkGetMetricTest, OVClassExecutableNetworkGetMetricTest_SUPPORTED_METRICS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassExecutableNetworkGetMetricTest, OVClassExecutableNetworkGetMetricTest_NETWORK_NAME, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassExecutableNetworkGetMetricTest, OVClassExecutableNetworkGetMetricTest_OPTIMAL_NUMBER_OF_INFER_REQUESTS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassExecutableNetworkGetMetricTest, OVClassExecutableNetworkGetMetricTest_ThrowsUnsupported, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +// +// Executable Network GetConfig / SetConfig +// + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassExecutableNetworkGetConfigTest, OVClassExecutableNetworkGetConfigTest, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassExecutableNetworkSetConfigTest, OVClassExecutableNetworkSetConfigTest, + ::testing::Values(ConformanceTests::targetDevice)); + +//// +//// Hetero Executable Network GetMetric +//// + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassHeteroExecutableNetworkGetMetricTest, OVClassHeteroExecutableNetworkGetMetricTest_SUPPORTED_CONFIG_KEYS, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassHeteroExecutableNetworkGetMetricTest, OVClassHeteroExecutableNetworkGetMetricTest_SUPPORTED_METRICS, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassHeteroExecutableNetworkGetMetricTest, OVClassHeteroExecutableNetworkGetMetricTest_NETWORK_NAME, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassHeteroExecutableNetworkGetMetricTest, OVClassHeteroExecutableNetworkGetMetricTest_TARGET_FALLBACK, + ::testing::Values(ConformanceTests::targetDevice)); + +////////////////////////////////////////////////////////////////////////////////////////// + +} // namespace + diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/callback.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/callback.cpp new file mode 100644 index 00000000000..615cee7b1a0 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/callback.cpp @@ -0,0 +1,37 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "behavior/ov_infer_request/callback.hpp" +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestCallbackTests, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferRequestCallbackTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVInferRequestCallbackTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVInferRequestCallbackTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestCallbackTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVInferRequestCallbackTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVInferRequestCallbackTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVInferRequestCallbackTests::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/cancellation.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/cancellation.cpp new file mode 100644 index 00000000000..1b7e6ad7d51 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/cancellation.cpp @@ -0,0 +1,17 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_infer_request/cancellation.hpp" +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestCancellationTests, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferRequestCancellationTests::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/infer_request_dynamic.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/infer_request_dynamic.cpp new file mode 100644 index 00000000000..3725b6afa37 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/infer_request_dynamic.cpp @@ -0,0 +1,106 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "behavior/ov_infer_request/infer_request_dynamic.hpp" +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { + +std::shared_ptr ovGetFunction1() { + const std::vector inputShape = {1, 4, 20, 20}; + const ngraph::element::Type_t ngPrc = ngraph::element::Type_t::f32; + + auto params = ngraph::builder::makeParams(ngPrc, {inputShape}); + params.front()->set_friendly_name("Param_1"); + params.front()->get_output_tensor(0).set_names({"input_tensor"}); + + auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 4, 1, 1}, std::vector{}, true); + auto add = ngraph::builder::makeEltwise(params[0], in2add, ngraph::helpers::EltwiseTypes::ADD); + auto relu1 = std::make_shared(add->output(0)); + relu1->get_output_tensor(0).set_names({"relu1"}); + auto relu2 = std::make_shared(add->output(0)); + relu2->get_output_tensor(0).set_names({"relu2"}); + + ngraph::NodeVector results{relu1, relu2}; + return std::make_shared(results, params, "AddTwoOutputEdges"); +} + +std::shared_ptr ovGetFunction2() { + const std::vector inputShape = {1, 4, 20, 20}; + const ngraph::element::Type_t ngPrc = ngraph::element::Type_t::f32; + + auto params = ngraph::builder::makeParams(ngPrc, {inputShape}); + params.front()->set_friendly_name("Param_1"); + params.front()->get_output_tensor(0).set_names({"input_tensor"}); + auto split = ngraph::builder::makeSplit(params[0], ngPrc, 2, 1); + + auto in2add = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector{}, true); + auto add = ngraph::builder::makeEltwise(split->output(0), in2add, ngraph::helpers::EltwiseTypes::ADD); + auto relu1 = std::make_shared(add); + + auto in2mult = ngraph::builder::makeConstant(ngPrc, {1, 2, 1, 1}, std::vector{}, true); + auto mult = ngraph::builder::makeEltwise(split->output(1), in2mult, ngraph::helpers::EltwiseTypes::MULTIPLY); + auto relu2 = std::make_shared(mult); + + auto concat = std::make_shared(ngraph::OutputVector{relu1->output(0), relu2->output(0)}, 3); + concat->get_output_tensor(0).set_names({"concat"}); + + return std::make_shared(concat, params, "SplitAddConcat"); +} + +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests_1, OVInferRequestDynamicTests, + ::testing::Combine( + ::testing::Values(ovGetFunction1()), + ::testing::Values(std::vector, std::vector>>{ + {{1, 4, 20, 20}, {1, 4, 20, 20}}, + {{2, 4, 20, 20}, {2, 4, 20, 20}}}), + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferRequestDynamicTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests_2, OVInferRequestDynamicTests, + ::testing::Combine( + ::testing::Values(ovGetFunction2()), + ::testing::Values(std::vector, std::vector>>{ + {{1, 4, 20, 20}, {1, 2, 20, 40}}, + {{2, 4, 20, 20}, {2, 2, 20, 40}}}), + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferRequestDynamicTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVInferRequestDynamicTests, + ::testing::Combine( + ::testing::Values(ovGetFunction2()), + ::testing::Values(std::vector, std::vector>>{ + {{1, 4, 20, 20}, {1, 2, 20, 40}}, + {{2, 4, 20, 20}, {2, 2, 20, 40}}}), + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVInferRequestDynamicTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVInferRequestDynamicTests, + ::testing::Combine( + ::testing::Values(ovGetFunction2()), + ::testing::Values(std::vector, std::vector>>{ + {{1, 4, 20, 20}, {1, 2, 20, 40}}, + {{2, 4, 20, 20}, {2, 2, 20, 40}}}), + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVInferRequestDynamicTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestDynamicTests, + ::testing::Combine( + ::testing::Values(ovGetFunction2()), + ::testing::Values(std::vector, std::vector>>{ + {{1, 4, 20, 20}, {1, 2, 20, 40}}, + {{2, 4, 20, 20}, {2, 2, 20, 40}}}), + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVInferRequestDynamicTests::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/inference_chaining.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/inference_chaining.cpp new file mode 100644 index 00000000000..8f93e90a805 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/inference_chaining.cpp @@ -0,0 +1,36 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_infer_request/inference_chaining.hpp" +#include "common_test_utils/test_constants.hpp" +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferenceChaining, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferenceChaining::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVInferenceChaining, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVInferenceChaining::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVInferenceChaining, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVInferenceChaining::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferenceChaining, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVInferenceChaining::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/io_tensor.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/io_tensor.cpp new file mode 100644 index 00000000000..5020ee2f95f --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/io_tensor.cpp @@ -0,0 +1,85 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "behavior/ov_infer_request/io_tensor.hpp" + +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestIOTensorTest, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferRequestIOTensorTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVInferRequestIOTensorTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVInferRequestIOTensorTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestIOTensorTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVInferRequestIOTensorTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVInferRequestIOTensorTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVInferRequestIOTensorTest::getTestCaseName); + +std::vector ovIOTensorElemTypes = { + ov::element::boolean, + ov::element::bf16, + ov::element::f16, + ov::element::f32, + ov::element::f64, + ov::element::i4, + ov::element::i8, + ov::element::i16, + ov::element::i32, + ov::element::i64, + ov::element::u1, + ov::element::u4, + ov::element::u8, + ov::element::u16, + ov::element::u32, + ov::element::u64, +}; + +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestIOTensorSetPrecisionTest, + ::testing::Combine( + ::testing::ValuesIn(ovIOTensorElemTypes), + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferRequestIOTensorSetPrecisionTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVInferRequestIOTensorSetPrecisionTest, + ::testing::Combine( + ::testing::ValuesIn(ovIOTensorElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVInferRequestIOTensorSetPrecisionTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestIOTensorSetPrecisionTest, + ::testing::Combine( + ::testing::ValuesIn(ovIOTensorElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVInferRequestIOTensorSetPrecisionTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVInferRequestIOTensorSetPrecisionTest, + ::testing::Combine( + ::testing::ValuesIn(ovIOTensorElemTypes), + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVInferRequestIOTensorSetPrecisionTest::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/multithreading.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/multithreading.cpp new file mode 100644 index 00000000000..52d6543bdb7 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/multithreading.cpp @@ -0,0 +1,39 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "behavior/ov_infer_request/multithreading.hpp" + +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestMultithreadingTests, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferRequestMultithreadingTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVInferRequestMultithreadingTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVInferRequestMultithreadingTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestMultithreadingTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVInferRequestMultithreadingTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVInferRequestMultithreadingTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVInferRequestMultithreadingTests::getTestCaseName); + +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/perf_counters.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/perf_counters.cpp new file mode 100644 index 00000000000..322df2ffec4 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/perf_counters.cpp @@ -0,0 +1,35 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_infer_request/perf_counters.hpp" +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestPerfCountersTest, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferRequestPerfCountersTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVInferRequestPerfCountersTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVInferRequestPerfCountersTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestPerfCountersTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVInferRequestPerfCountersTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVInferRequestPerfCountersTest, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVInferRequestPerfCountersTest::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/wait.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/wait.cpp new file mode 100644 index 00000000000..6ecf0c80af4 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_infer_request/wait.cpp @@ -0,0 +1,38 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "behavior/ov_infer_request/wait.hpp" + +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; + +namespace { +INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, OVInferRequestWaitTests, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(emptyConfig)), + OVInferRequestWaitTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, OVInferRequestWaitTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), + OVInferRequestWaitTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, OVInferRequestWaitTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + OVInferRequestWaitTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, OVInferRequestWaitTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), + OVInferRequestWaitTests::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_plugin/core_integration.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_plugin/core_integration.cpp new file mode 100644 index 00000000000..147f727babc --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/ov_plugin/core_integration.cpp @@ -0,0 +1,94 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/ov_plugin/core_integration.hpp" +#include "openvino/runtime/core.hpp" +#include "api_conformance_helpers.hpp" + +using namespace ov::test::behavior; +using namespace ov::test::conformance; +using namespace InferenceEngine::PluginConfigParams; + +namespace { +// +// IE Class Common tests with +// + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassCommon, OVClassBasicTestP, + ::testing::Values(std::make_pair(getPluginLibNameByDevice(ConformanceTests::targetDevice), ConformanceTests::targetDevice))); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassNetworkTestP, OVClassNetworkTestP, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassImportExportTestP, OVClassImportExportTestP, + ::testing::Values(generateComplexDeviceName(ConformanceTests::targetDevice))); + +// +// IE Class GetMetric +// + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetMetricTest, OVClassGetMetricTest_SUPPORTED_CONFIG_KEYS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetMetricTest, OVClassGetMetricTest_SUPPORTED_METRICS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetMetricTest, OVClassGetMetricTest_AVAILABLE_DEVICES, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetMetricTest, OVClassGetMetricTest_FULL_DEVICE_NAME, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetMetricTest, OVClassGetMetricTest_OPTIMIZATION_CAPABILITIES, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetMetricTest, OVClassGetMetricTest_RANGE_FOR_ASYNC_INFER_REQUESTS, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetMetricTest, OVClassGetMetricTest_RANGE_FOR_STREAMS, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetMetricTest, OVClassGetMetricTest_ThrowUnsupported, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetConfigTest, OVClassGetConfigTest_ThrowUnsupported, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetAvailableDevices, OVClassGetAvailableDevices, + ::testing::Values(ConformanceTests::targetDevice)); + +// +// IE Class GetConfig +// + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassGetConfigTest, OVClassGetConfigTest, + ::testing::Values(ConformanceTests::targetDevice)); + +// IE Class Query network + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassQueryNetworkTest, OVClassQueryNetworkTest, + ::testing::Values(ConformanceTests::targetDevice)); + +// IE Class Load network + +INSTANTIATE_TEST_SUITE_P( + smoke_OVClassLoadNetworkTest, OVClassLoadNetworkTest, + ::testing::Values(ConformanceTests::targetDevice)); +} // namespace + diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/configuration_tests.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/configuration_tests.cpp new file mode 100644 index 00000000000..4a7caf2004b --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/configuration_tests.cpp @@ -0,0 +1,132 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "ie_plugin_config.hpp" +#include "ie_system_conf.h" +#include "behavior/plugin/configuration_tests.hpp" +#include "api_conformance_helpers.hpp" + +using namespace BehaviorTestsDefinitions; +using namespace ov::test::conformance; + +namespace { + #if (defined(__APPLE__) || defined(_WIN32)) + auto defaultBindThreadParameter = InferenceEngine::Parameter{[] { + auto numaNodes = InferenceEngine::getAvailableNUMANodes(); + if (numaNodes.size() > 1) { + return std::string{CONFIG_VALUE(NUMA)}; + } else { + return std::string{CONFIG_VALUE(NO)}; + } + }()}; + #else + auto defaultBindThreadParameter = InferenceEngine::Parameter{std::string{CONFIG_VALUE(YES)}}; + #endif + const std::vector> pluginConfigs = { + {}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::THROUGHPUT}}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY}}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "1"}}, + {{InferenceEngine::PluginConfigParams::KEY_DYN_BATCH_LIMIT, "10"}}, + // check that hints doesn't override customer value (now for streams and later for other config opts) + }; + + const std::vector> pluginMultiConfigs = { + {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_CPU}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::THROUGHPUT}}, + {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_CPU}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY}}, + {{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , CommonTestUtils::DEVICE_CPU}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "1"}} + }; + + INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, CorrectConfigTests, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(pluginConfigs)), + CorrectConfigTests::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, CorrectConfigTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI, pluginMultiConfigs))), + CorrectConfigTests::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, CorrectConfigTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO, pluginMultiConfigs))), + CorrectConfigTests::getTestCaseName); + + const std::vector> inPluginConfigs = { + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, "DOESN'T EXIST"}}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "-1"}}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::THROUGHPUT}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "should be int"}}, + {{InferenceEngine::PluginConfigParams::KEY_DYN_BATCH_LIMIT, "NAN"}} + }; + + const std::vector> pluginMultiInConfigs = { + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, "DOESN'T EXIST"}}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "-1"}}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::THROUGHPUT}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "should be int"}}, + {{InferenceEngine::PluginConfigParams::KEY_DYN_BATCH_LIMIT, "NAN"}} + }; + + INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, IncorrectConfigTests, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(inPluginConfigs)), + IncorrectConfigTests::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, IncorrectConfigTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI, pluginMultiInConfigs))), + IncorrectConfigTests::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, IncorrectConfigTests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO, pluginMultiInConfigs))), + IncorrectConfigTests::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, IncorrectConfigAPITests, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(inPluginConfigs)), + IncorrectConfigAPITests::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, IncorrectConfigAPITests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI, pluginMultiInConfigs))), + IncorrectConfigAPITests::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, IncorrectConfigAPITests, + ::testing::Combine( + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO, pluginMultiInConfigs))), + IncorrectConfigAPITests::getTestCaseName); + + const std::vector> pluginConfigsCheck = { + {}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::THROUGHPUT}}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY}}, + {{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY}, + {InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "1"}}, + {{InferenceEngine::PluginConfigParams::KEY_DYN_BATCH_LIMIT, "10"}} + }; + + INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, CorrectConfigCheck, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(pluginConfigsCheck)), + CorrectConfigCheck::getTestCaseName); +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/core_integration.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/core_integration.cpp new file mode 100644 index 00000000000..32810241f69 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/core_integration.cpp @@ -0,0 +1,103 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/plugin/core_integration.hpp" +#include "api_conformance_helpers.hpp" + +using namespace BehaviorTestsDefinitions; +using namespace ov::test::conformance; +using namespace InferenceEngine::PluginConfigParams; + +namespace { +// +// IE Class Common tests with +// + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassCommon, IEClassBasicTestP, + ::testing::Values(std::make_pair(getPluginLibNameByDevice(ConformanceTests::targetDevice), ConformanceTests::targetDevice))); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassNetworkTestP, IEClassNetworkTestP, + ::testing::Values(ConformanceTests::targetDevice)); + +// +// IE Class GetMetric +// + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetMetricTest, IEClassGetMetricTest_SUPPORTED_CONFIG_KEYS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetMetricTest, IEClassGetMetricTest_SUPPORTED_METRICS, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetMetricTest, IEClassGetMetricTest_AVAILABLE_DEVICES, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetMetricTest, IEClassGetMetricTest_FULL_DEVICE_NAME, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetMetricTest, IEClassGetMetricTest_OPTIMIZATION_CAPABILITIES, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetMetricTest, IEClassGetMetricTest_RANGE_FOR_ASYNC_INFER_REQUESTS, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetMetricTest, IEClassGetMetricTest_RANGE_FOR_STREAMS, + ::testing::Values(ConformanceTests::targetDevice)); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetMetricTest, IEClassGetMetricTest_ThrowUnsupported, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetConfigTest, IEClassGetConfigTest_ThrowUnsupported, + ::testing::ValuesIn(returnAllPossibleDeviceCombination())); + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetAvailableDevices, IEClassGetAvailableDevices, + ::testing::Values(ConformanceTests::targetDevice)); + +// +// IE Class GetConfig +// + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassGetConfigTest, IEClassGetConfigTest, + ::testing::Values(ConformanceTests::targetDevice)); + +////////////////////////////////////////////////////////////////////////////////////////// + +TEST(IEClassBasicTest, smoke_SetConfigAfterCreatedThrow) { + InferenceEngine::Core ie; + std::string value = {}; + + ASSERT_NO_THROW(ie.SetConfig({{KEY_CPU_THREADS_NUM, "1"}}, ConformanceTests::targetDevice)); + ASSERT_NO_THROW(value = ie.GetConfig(ConformanceTests::targetDevice, KEY_CPU_THREADS_NUM).as()); + ASSERT_EQ("1", value); + + ASSERT_NO_THROW(ie.SetConfig({{KEY_CPU_THREADS_NUM, "4"}}, ConformanceTests::targetDevice)); + ASSERT_NO_THROW(value = ie.GetConfig(ConformanceTests::targetDevice, KEY_CPU_THREADS_NUM).as()); + ASSERT_EQ("4", value); +} + +// IE Class Query network + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassQueryNetworkTest, IEClassQueryNetworkTest, + ::testing::Values(ConformanceTests::targetDevice)); + +// IE Class Load network + +INSTANTIATE_TEST_SUITE_P( + smoke_IEClassLoadNetworkTest, IEClassLoadNetworkTest, + ::testing::Values(ConformanceTests::targetDevice)); +} // namespace \ No newline at end of file diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/core_threading_tests.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/core_threading_tests.cpp new file mode 100644 index 00000000000..40e0a65c3d0 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/core_threading_tests.cpp @@ -0,0 +1,31 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include +#include "api_conformance_helpers.hpp" + +namespace { +using namespace ov::test::conformance; + +const Params coreThreadingParams[] = { + std::tuple{ CommonTestUtils::DEVICE_HETERO, generateConfigs(CommonTestUtils::DEVICE_HETERO).front() }, + std::tuple{ CommonTestUtils::DEVICE_MULTI, generateConfigs(CommonTestUtils::DEVICE_MULTI).front() }, + std::tuple{ CommonTestUtils::DEVICE_AUTO, generateConfigs(CommonTestUtils::DEVICE_AUTO).front() }, +}; + +INSTANTIATE_TEST_SUITE_P(Conformance_, CoreThreadingTests, testing::ValuesIn(coreThreadingParams), CoreThreadingTests::getTestCaseName); +INSTANTIATE_TEST_SUITE_P(Conformance, CoreThreadingTests, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::Values(Config{{ CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES) }})), + CoreThreadingTests::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(Conformance, CoreThreadingTestsWithIterations, + testing::Combine(testing::ValuesIn(coreThreadingParams), + testing::Values(4), + testing::Values(50), + testing::Values(ModelClass::Default)), + CoreThreadingTestsWithIterations::getTestCaseName); + +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/life_time.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/life_time.cpp new file mode 100644 index 00000000000..090bc9fdab1 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/life_time.cpp @@ -0,0 +1,32 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/plugin/life_time.hpp" +#include "api_conformance_helpers.hpp" + +using namespace BehaviorTestsDefinitions; +using namespace ov::test::conformance; +namespace { + const std::vector> orders = { + // 0 - plugin + // 1 - executable_network + // 2 - infer_request + // 3 - variable state + {3, 0, 1, 2}, + {3, 0, 2, 1}, + {3, 1, 0, 2}, + {3, 1, 2, 0}, + {3, 2, 0, 1}, + {3, 2, 1, 0}, + {0, 3, 1, 2}, + {0, 1, 3, 2} + }; + + INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, HoldersTest, + ::testing::Combine( + ::testing::Values(ConformanceTests::targetDevice), + ::testing::ValuesIn(orders)), + HoldersTest::getTestCaseName); + +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/version.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/version.cpp new file mode 100644 index 00000000000..77aa9dab002 --- /dev/null +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/version.cpp @@ -0,0 +1,27 @@ +// Copyright (C) 2018-2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "behavior/plugin/version.hpp" +#include "api_conformance_helpers.hpp" + +using namespace BehaviorTestsDefinitions; +namespace { + INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, VersionTest, + ::testing::Values(ConformanceTests::targetDevice), + VersionTest::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, VersionTest, + ::testing::Values(CommonTestUtils::DEVICE_MULTI), + VersionTest::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, VersionTest, + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + VersionTest::getTestCaseName); + + INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, VersionTest, + ::testing::Values(CommonTestUtils::DEVICE_HETERO), + VersionTest::getTestCaseName); + + +} // namespace diff --git a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/preprocessing/set_preprocess.cpp b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/preprocessing/set_preprocess.cpp index e3fc083aec6..773c5b2f90a 100644 --- a/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/preprocessing/set_preprocess.cpp +++ b/inference-engine/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/preprocessing/set_preprocess.cpp @@ -3,14 +3,14 @@ // #include "behavior/preprocessing/set_preprocess.hpp" -#include "conformance.hpp" +#include "api_conformance_helpers.hpp" namespace { -using namespace ConformanceTests; using namespace BehaviorTestsDefinitions; +using namespace ov::test::conformance; -const std::vector netPrecisions = { +const std::vector netPrecisionsPreprocess = { InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP16 }; @@ -19,171 +19,158 @@ const std::vector> configs = { {}, }; -const std::vector> heteroConfigs = { - {{ "TARGET_FALLBACK" , targetDevice}} -}; - -const std::vector> multiConfigs = { - {{ InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , targetDevice}} -}; - -const std::vector> autoConfigs = { - {{ InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , targetDevice}} -}; - INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestPreprocessTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), - ::testing::Values(targetDevice), + ::testing::ValuesIn(netPrecisionsPreprocess), + ::testing::Values(ConformanceTests::targetDevice), ::testing::ValuesIn(configs)), InferRequestPreprocessTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, InferRequestPreprocessTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), + ::testing::ValuesIn(netPrecisionsPreprocess), ::testing::Values(CommonTestUtils::DEVICE_HETERO), - ::testing::ValuesIn(heteroConfigs)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), InferRequestPreprocessTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, InferRequestPreprocessTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), + ::testing::ValuesIn(netPrecisionsPreprocess), ::testing::Values(CommonTestUtils::DEVICE_MULTI), - ::testing::ValuesIn(multiConfigs)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), InferRequestPreprocessTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestPreprocessTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), + ::testing::ValuesIn(netPrecisionsPreprocess), ::testing::Values(CommonTestUtils::DEVICE_AUTO), - ::testing::ValuesIn(autoConfigs)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), InferRequestPreprocessTest::getTestCaseName); -const std::vector ioPrecisions = { +const std::vector ioPrecisionsPreprocess = { InferenceEngine::Precision::FP32, InferenceEngine::Precision::U8 }; -const std::vector netLayouts = { +const std::vector netLayoutsPreprocess = { InferenceEngine::Layout::NCHW, // InferenceEngine::Layout::NHWC }; -const std::vector ioLayouts = { +const std::vector ioLayoutsPreprocess = { InferenceEngine::Layout::NCHW, InferenceEngine::Layout::NHWC }; INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestPreprocessConversionTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), - ::testing::ValuesIn(ioPrecisions), - ::testing::ValuesIn(ioPrecisions), - ::testing::ValuesIn(netLayouts), - ::testing::ValuesIn(ioLayouts), - ::testing::ValuesIn(ioLayouts), + ::testing::ValuesIn(netPrecisionsPreprocess), + ::testing::ValuesIn(ioPrecisionsPreprocess), + ::testing::ValuesIn(ioPrecisionsPreprocess), + ::testing::ValuesIn(netLayoutsPreprocess), + ::testing::ValuesIn(ioLayoutsPreprocess), + ::testing::ValuesIn(ioLayoutsPreprocess), ::testing::Bool(), ::testing::Bool(), - ::testing::Values(targetDevice), + ::testing::Values(ConformanceTests::targetDevice), ::testing::ValuesIn(configs)), InferRequestPreprocessConversionTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTests, InferRequestPreprocessDynamicallyInSetBlobTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), + ::testing::ValuesIn(netPrecisionsPreprocess), ::testing::Bool(), ::testing::Bool(), - ::testing::ValuesIn(netLayouts), + ::testing::ValuesIn(netLayoutsPreprocess), ::testing::Bool(), ::testing::Bool(), ::testing::Values(true), // only SetBlob ::testing::Values(true), // only SetBlob - ::testing::Values(targetDevice), + ::testing::Values(ConformanceTests::targetDevice), ::testing::ValuesIn(configs)), InferRequestPreprocessDynamicallyInSetBlobTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, InferRequestPreprocessConversionTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), - ::testing::ValuesIn(ioPrecisions), - ::testing::ValuesIn(ioPrecisions), - ::testing::ValuesIn(netLayouts), - ::testing::ValuesIn(ioLayouts), - ::testing::ValuesIn(ioLayouts), + ::testing::ValuesIn(netPrecisionsPreprocess), + ::testing::ValuesIn(ioPrecisionsPreprocess), + ::testing::ValuesIn(ioPrecisionsPreprocess), + ::testing::ValuesIn(netLayoutsPreprocess), + ::testing::ValuesIn(ioLayoutsPreprocess), + ::testing::ValuesIn(ioLayoutsPreprocess), ::testing::Bool(), ::testing::Bool(), ::testing::Values(CommonTestUtils::DEVICE_HETERO), - ::testing::ValuesIn(heteroConfigs)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), InferRequestPreprocessConversionTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Hetero_BehaviorTests, InferRequestPreprocessDynamicallyInSetBlobTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), + ::testing::ValuesIn(netPrecisionsPreprocess), ::testing::Bool(), ::testing::Bool(), - ::testing::ValuesIn(netLayouts), + ::testing::ValuesIn(netLayoutsPreprocess), ::testing::Bool(), ::testing::Bool(), ::testing::Values(true), // only SetBlob ::testing::Values(true), // only SetBlob ::testing::Values(CommonTestUtils::DEVICE_HETERO), - ::testing::ValuesIn(heteroConfigs)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_HETERO))), InferRequestPreprocessDynamicallyInSetBlobTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, InferRequestPreprocessConversionTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), - ::testing::ValuesIn(ioPrecisions), - ::testing::ValuesIn(ioPrecisions), - ::testing::ValuesIn(netLayouts), - ::testing::ValuesIn(ioLayouts), - ::testing::ValuesIn(ioLayouts), + ::testing::ValuesIn(netPrecisionsPreprocess), + ::testing::ValuesIn(ioPrecisionsPreprocess), + ::testing::ValuesIn(ioPrecisionsPreprocess), + ::testing::ValuesIn(netLayoutsPreprocess), + ::testing::ValuesIn(ioLayoutsPreprocess), + ::testing::ValuesIn(ioLayoutsPreprocess), ::testing::Bool(), ::testing::Bool(), ::testing::Values(CommonTestUtils::DEVICE_MULTI), - ::testing::ValuesIn(multiConfigs)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), InferRequestPreprocessConversionTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Multi_BehaviorTests, InferRequestPreprocessDynamicallyInSetBlobTest, ::testing::Combine( - ::testing::ValuesIn(netPrecisions), + ::testing::ValuesIn(netPrecisionsPreprocess), ::testing::Bool(), ::testing::Bool(), - ::testing::ValuesIn(netLayouts), + ::testing::ValuesIn(netLayoutsPreprocess), ::testing::Bool(), ::testing::Bool(), ::testing::Values(true), // only SetBlob ::testing::Values(true), // only SetBlob ::testing::Values(CommonTestUtils::DEVICE_MULTI), - ::testing::ValuesIn(multiConfigs)), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_MULTI))), InferRequestPreprocessDynamicallyInSetBlobTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestPreprocessConversionTest, - ::testing::Combine( - ::testing::ValuesIn(netPrecisions), - ::testing::ValuesIn(ioPrecisions), - ::testing::ValuesIn(ioPrecisions), - ::testing::ValuesIn(netLayouts), - ::testing::ValuesIn(ioLayouts), - ::testing::ValuesIn(ioLayouts), - ::testing::Bool(), - ::testing::Bool(), - ::testing::Values(CommonTestUtils::DEVICE_AUTO), - ::testing::ValuesIn(autoConfigs)), - InferRequestPreprocessConversionTest::getTestCaseName); + ::testing::Combine( + ::testing::ValuesIn(netPrecisionsPreprocess), + ::testing::ValuesIn(ioPrecisionsPreprocess), + ::testing::ValuesIn(ioPrecisionsPreprocess), + ::testing::ValuesIn(netLayoutsPreprocess), + ::testing::ValuesIn(ioLayoutsPreprocess), + ::testing::ValuesIn(ioLayoutsPreprocess), + ::testing::Bool(), + ::testing::Bool(), + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + InferRequestPreprocessConversionTest::getTestCaseName); INSTANTIATE_TEST_SUITE_P(smoke_Auto_BehaviorTests, InferRequestPreprocessDynamicallyInSetBlobTest, - ::testing::Combine( - ::testing::ValuesIn(netPrecisions), - ::testing::Bool(), - ::testing::Bool(), - ::testing::ValuesIn(netLayouts), - ::testing::Bool(), - ::testing::Bool(), - ::testing::Values(true), // only SetBlob - ::testing::Values(true), // only SetBlob - ::testing::Values(CommonTestUtils::DEVICE_AUTO), - ::testing::ValuesIn(autoConfigs)), - InferRequestPreprocessDynamicallyInSetBlobTest::getTestCaseName); - + ::testing::Combine( + ::testing::ValuesIn(netPrecisionsPreprocess), + ::testing::Bool(), + ::testing::Bool(), + ::testing::ValuesIn(netLayoutsPreprocess), + ::testing::Bool(), + ::testing::Bool(), + ::testing::Values(true), // only SetBlob + ::testing::Values(true), // only SetBlob + ::testing::Values(CommonTestUtils::DEVICE_AUTO), + ::testing::ValuesIn(generateConfigs(CommonTestUtils::DEVICE_AUTO))), + InferRequestPreprocessDynamicallyInSetBlobTest::getTestCaseName); } // namespace