IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[apiConformance] Remove 1.0 api tests (#20185)

Browse Source
This commit is contained in:
Sofya Balandina 2023-10-03 17:07:10 +01:00 committed by GitHub
parent d5ea8d5a92
commit 379ff62575
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 0 additions and 769 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/exec_graph_info.cpp
View File

@ -1,29 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <common_test_utils/test_constants.hpp>
#include <exec_graph_info.hpp>
#include "behavior/executable_network/exec_graph_info.hpp"
#include "api_conformance_helpers.hpp"
namespace {
using namespace ExecutionGraphTests;
INSTANTIATE_TEST_SUITE_P(ie_executable_network, ExecGraphSerializationTest,
::testing::ValuesIn(ov::test::conformance::return_all_possible_device_combination()),
ExecGraphSerializationTest::getTestCaseName);
const std::vector<InferenceEngine::Precision> execGraphInfoElemTypes = {
InferenceEngine::Precision::FP32
};
INSTANTIATE_TEST_SUITE_P(ie_executable_network, ExecGraphUniqueNodeNames,
::testing::Combine(
::testing::ValuesIn(execGraphInfoElemTypes),
::testing::Values(InferenceEngine::SizeVector({1, 2, 5, 5})),
::testing::ValuesIn(ov::test::conformance::return_all_possible_device_combination())),
ExecGraphUniqueNodeNames::getTestCaseName);
} // namespace

42
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/exec_network_base.cpp
View File

@ -1,42 +0,0 @@
// Copyright (C) 2018-2023 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(ie_executable_network, ExecutableNetworkBaseTest,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
ExecutableNetworkBaseTest::getTestCaseName);
const std::vector<InferenceEngine::Precision> execNetBaseElemTypes = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16,
InferenceEngine::Precision::FP64,
InferenceEngine::Precision::BF16,
InferenceEngine::Precision::U8,
InferenceEngine::Precision::U16,
InferenceEngine::Precision::U32,
InferenceEngine::Precision::U64,
InferenceEngine::Precision::I8,
InferenceEngine::Precision::I16,
InferenceEngine::Precision::I32,
InferenceEngine::Precision::I64,
InferenceEngine::Precision::BOOL,
};
INSTANTIATE_TEST_SUITE_P(ie_executable_network, ExecNetSetPrecision,
::testing::Combine(
::testing::ValuesIn(execNetBaseElemTypes),
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
ExecNetSetPrecision::getTestCaseName);
} // namespace

74
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/get_metric.cpp
View File

@ -1,74 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/executable_network/get_metric.hpp"
#include "api_conformance_helpers.hpp"
using namespace BehaviorTestsDefinitions;
using namespace InferenceEngine::PluginConfigParams;
using namespace ov::test::conformance;
namespace {
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassImportExportTestP,
::testing::ValuesIn(return_all_possible_device_combination()));
//
// Executable Network GetMetric
//
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassExecutableNetworkGetMetricTest_SUPPORTED_CONFIG_KEYS,
::testing::ValuesIn(return_all_possible_device_combination()));
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassExecutableNetworkGetMetricTest_SUPPORTED_METRICS,
::testing::ValuesIn(return_all_possible_device_combination()));
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassExecutableNetworkGetMetricTest_NETWORK_NAME,
::testing::ValuesIn(return_all_possible_device_combination()));
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassExecutableNetworkGetMetricTest_OPTIMAL_NUMBER_OF_INFER_REQUESTS,
::testing::ValuesIn(return_all_possible_device_combination()));
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassExecutableNetworkGetMetricTest_ThrowsUnsupported,
::testing::ValuesIn(return_all_possible_device_combination()));
//
// Executable Network GetConfig / SetConfig
//
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassExecutableNetworkGetConfigTest,
::testing::ValuesIn(return_all_possible_device_combination()));
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassExecutableNetworkSetConfigTest,
::testing::ValuesIn(return_all_possible_device_combination()));
//
// Hetero Executable Network GetMetric
//
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassHeteroExecutableNetworkGetMetricTest_SUPPORTED_CONFIG_KEYS,
::testing::Values(targetDevice));
INSTANTIATE_TEST_SUITE_P(
smoke_IEClassHeteroExecutableNetworkGetMetricTest, IEClassHeteroExecutableNetworkGetMetricTest_SUPPORTED_METRICS,
::testing::Values(targetDevice));
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassHeteroExecutableNetworkGetMetricTest_NETWORK_NAME,
::testing::Values(targetDevice));
INSTANTIATE_TEST_SUITE_P(
ie_executable_network, IEClassHeteroExecutableNetworkGetMetricTest_TARGET_FALLBACK,
::testing::Values(targetDevice));
} // namespace

15
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/executable_network/locale.cpp
View File

@ -1,15 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/executable_network/locale.hpp"
#include "api_conformance_helpers.hpp"
using namespace BehaviorTestsDefinitions;
namespace {
INSTANTIATE_TEST_SUITE_P(ie_executable_network, CustomLocaleTest,
::testing::Combine(
::testing::Values("ru_RU.UTF-8"),
::testing::ValuesIn(ov::test::conformance::return_all_possible_device_combination())),
CustomLocaleTest::getTestCaseName);
} // namespace

17
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/callback.cpp
View File

@ -1,17 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/infer_request/callback.hpp"
#include "api_conformance_helpers.hpp"
namespace {
using namespace BehaviorTestsDefinitions;
using namespace ov::test::conformance;
INSTANTIATE_TEST_SUITE_P(ie_infer_request, InferRequestCallbackTests,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestCallbackTests::getTestCaseName);
} // namespace

17
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/cancellation.cpp
View File

@ -1,17 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/infer_request/cancellation.hpp"
#include "api_conformance_helpers.hpp"
namespace {
using namespace BehaviorTestsDefinitions;
using namespace ov::test::conformance;
INSTANTIATE_TEST_SUITE_P(ie_infer_request, InferRequestCancellationTests,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestCancellationTests::getTestCaseName);
} // namespace

20
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/io_blob.cpp
View File

@ -1,20 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "behavior/infer_request/io_blob.hpp"
#include "ie_plugin_config.hpp"
#include "api_conformance_helpers.hpp"
namespace {
using namespace BehaviorTestsDefinitions;
using namespace ov::test::conformance;
INSTANTIATE_TEST_SUITE_P(ie_infer_request, InferRequestIOBBlobTest,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestIOBBlobTest::getTestCaseName);
} // namespace

22
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/multitheading.cpp
View File

@ -1,22 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "behavior/infer_request/multithreading.hpp"
#include "ie_plugin_config.hpp"
#include "api_conformance_helpers.hpp"
namespace {
using namespace ov::test::conformance;
using namespace BehaviorTestsDefinitions;
INSTANTIATE_TEST_SUITE_P(ie_infer_request, InferRequestMultithreadingTests,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestMultithreadingTests::getTestCaseName);
} // namespace

18
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/perf_counters.cpp
View File

@ -1,18 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/infer_request/perf_counters.hpp"
#include "api_conformance_helpers.hpp"
namespace {
using namespace ov::test::conformance;
using namespace BehaviorTestsDefinitions;
INSTANTIATE_TEST_SUITE_P(ie_infer_request, InferRequestPerfCountersTest,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestPerfCountersTest::getTestCaseName);
} // namespace

24
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/set_blob_by_type.cpp
View File

@ -1,24 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/infer_request/set_blob_by_type.hpp"
#include "api_conformance_helpers.hpp"
namespace {
using namespace ov::test::conformance;
using namespace BehaviorTestsDefinitions;
const std::vector<FuncTestUtils::BlobType> setBlobTypes = {
FuncTestUtils::BlobType::Compound,
FuncTestUtils::BlobType::Batched,
FuncTestUtils::BlobType::Memory,
FuncTestUtils::BlobType::Remote,
};
INSTANTIATE_TEST_SUITE_P(ie_infer_request, InferRequestSetBlobByType,
::testing::Combine(::testing::ValuesIn(setBlobTypes),
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestSetBlobByType::getTestCaseName);
} // namespace

20
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/infer_request/wait.cpp
View File

@ -1,20 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "behavior/infer_request/wait.hpp"
#include "ie_plugin_config.hpp"
#include "api_conformance_helpers.hpp"
namespace {
using namespace ov::test::conformance;
using namespace BehaviorTestsDefinitions;
INSTANTIATE_TEST_SUITE_P(ie_infer_request, InferRequestWaitTests,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestWaitTests::getTestCaseName);
} // namespace

62
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/caching_tests.cpp
View File

@ -1,62 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/plugin/caching_tests.hpp"
#include <ov_ops/nms_ie_internal.hpp>
#include "api_conformance_helpers.hpp"
namespace {
using namespace ov::test::conformance;
using namespace LayerTestsDefinitions;
using namespace ngraph;
static const std::vector<ov::element::Type> 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<std::size_t> batchSizesTemplate = {
1, 2
};
static const std::vector<ov::element::Type> numericPrecisionsTemplate(precisionsTemplate.begin(),
precisionsTemplate.end() - 1);
static const std::vector<ov::element::Type> floatingPointPrecisionsTemplate(precisionsTemplate.begin(),
precisionsTemplate.begin() + 3);
INSTANTIATE_TEST_SUITE_P(ie_plugin_any_type, LoadNetworkCacheTestBase,
::testing::Combine(
::testing::ValuesIn(LoadNetworkCacheTestBase::getAnyTypeOnlyFunctions()),
::testing::ValuesIn(precisionsTemplate),
::testing::ValuesIn(batchSizesTemplate),
::testing::ValuesIn(return_all_possible_device_combination())),
LoadNetworkCacheTestBase::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_numeric, LoadNetworkCacheTestBase,
::testing::Combine(
::testing::ValuesIn(LoadNetworkCacheTestBase::getNumericTypeOnlyFunctions()),
::testing::ValuesIn(numericPrecisionsTemplate),
::testing::ValuesIn(batchSizesTemplate),
::testing::ValuesIn(return_all_possible_device_combination())),
LoadNetworkCacheTestBase::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_float, LoadNetworkCacheTestBase,
::testing::Combine(
::testing::ValuesIn(LoadNetworkCacheTestBase::getFloatingPointOnlyFunctions()),
::testing::ValuesIn(floatingPointPrecisionsTemplate),
::testing::ValuesIn(batchSizesTemplate),
::testing::ValuesIn(return_all_possible_device_combination())),
LoadNetworkCacheTestBase::getTestCaseName);
} // namespace

173
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/configuration_tests.cpp
View File

@ -1,173 +0,0 @@
// Copyright (C) 2018-2023 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
INSTANTIATE_TEST_SUITE_P(
ie_plugin,
DefaultConfigurationTest,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination(false)),
::testing::Values(DefaultParameter{CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(NO)})),
DefaultConfigurationTest::getTestCaseName);
const std::vector<std::map<std::string, std::string>> 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"}},
// check that hints doesn't override customer value (now for streams and later for other config opts)
};
const std::vector<std::map<std::string, std::string>> pluginMultiConfigs = {
{{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , ov::test::utils::DEVICE_CPU},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::THROUGHPUT}},
{{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , ov::test::utils::DEVICE_CPU},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY}},
{{InferenceEngine::MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES , ov::test::utils::DEVICE_CPU},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT, InferenceEngine::PluginConfigParams::LATENCY},
{InferenceEngine::PluginConfigParams::KEY_PERFORMANCE_HINT_NUM_REQUESTS, "1"}}
};
INSTANTIATE_TEST_SUITE_P(ie_plugin, CorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::conformance::targetDevice),
::testing::ValuesIn(pluginConfigs)),
CorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_Hetero, CorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_HETERO),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_HETERO, pluginConfigs))),
CorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_Multi, CorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_MULTI),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_MULTI, pluginMultiConfigs))),
CorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_Auto, CorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_AUTO),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_AUTO, pluginMultiConfigs))),
CorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_AutoBatch, CorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_BATCH),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_BATCH, pluginConfigs))),
CorrectConfigTests::getTestCaseName);
const std::vector<std::map<std::string, std::string>> 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"}},
};
const std::vector<std::map<std::string, std::string>> 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"}}
};
INSTANTIATE_TEST_SUITE_P(ie_plugin, IncorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::conformance::targetDevice),
::testing::ValuesIn(inPluginConfigs)),
IncorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_Hetero, IncorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_HETERO),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_HETERO, inPluginConfigs))),
IncorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_Multi, IncorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_MULTI),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_MULTI, pluginMultiInConfigs))),
IncorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_Auto, IncorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_AUTO),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_AUTO, pluginMultiInConfigs))),
IncorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_AutoBatch, IncorrectConfigTests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_BATCH),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_BATCH, pluginMultiInConfigs))),
IncorrectConfigTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin, IncorrectConfigAPITests,
::testing::Combine(
::testing::Values(ov::test::conformance::targetDevice),
::testing::ValuesIn(inPluginConfigs)),
IncorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_Hetero, IncorrectConfigAPITests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_HETERO),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_HETERO, inPluginConfigs))),
IncorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_Multi, IncorrectConfigAPITests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_MULTI),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_MULTI, pluginMultiInConfigs))),
IncorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_Auto, IncorrectConfigAPITests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_AUTO),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_AUTO, pluginMultiInConfigs))),
IncorrectConfigAPITests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin_AutoBatch, IncorrectConfigAPITests,
::testing::Combine(
::testing::Values(ov::test::utils::DEVICE_BATCH),
::testing::ValuesIn(generate_configs(ov::test::utils::DEVICE_BATCH, inPluginConfigs))),
IncorrectConfigAPITests::getTestCaseName);
const std::vector<std::map<std::string, std::string>> 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"}},
};
INSTANTIATE_TEST_SUITE_P(ie_plugin, CorrectConfigCheck,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::ValuesIn(pluginConfigsCheck)),
CorrectConfigCheck::getTestCaseName);
} // namespace

88
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/core_integration.cpp
View File

@ -1,88 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/plugin/core_integration.hpp"
#include "api_conformance_helpers.hpp"
using namespace BehaviorTestsDefinitions;
using namespace InferenceEngine::PluginConfigParams;
using namespace ov::test::conformance;
namespace {
//
// IE Class Common tests with <pluginName, deviceName params>
//
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassBasicTestP,
::testing::ValuesIn(generate_pairs_plugin_name_by_device()));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassNetworkTestP,
::testing::ValuesIn(return_all_possible_device_combination()));
//
// IE Class GetMetric
//
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetMetricTest_SUPPORTED_CONFIG_KEYS,
::testing::ValuesIn(return_all_possible_device_combination(false)));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetMetricTest_SUPPORTED_METRICS,
::testing::ValuesIn(return_all_possible_device_combination(false)));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetMetricTest_AVAILABLE_DEVICES,
::testing::ValuesIn(return_all_possible_device_combination(false)));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetMetricTest_FULL_DEVICE_NAME,
::testing::ValuesIn(return_all_possible_device_combination(false)));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetMetricTest_OPTIMIZATION_CAPABILITIES,
::testing::ValuesIn(return_all_possible_device_combination(false)));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetMetricTest_RANGE_FOR_ASYNC_INFER_REQUESTS,
::testing::ValuesIn(return_all_possible_device_combination(false)));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetMetricTest_RANGE_FOR_STREAMS,
::testing::ValuesIn(return_all_possible_device_combination(false)));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetMetricTest_ThrowUnsupported,
::testing::ValuesIn(return_all_possible_device_combination(false)));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetConfigTest_ThrowUnsupported,
::testing::ValuesIn(return_all_possible_device_combination(false)));
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetAvailableDevices,
::testing::Values(targetDevice));
//
// IE Class GetConfig
//
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassGetConfigTest,
::testing::ValuesIn(return_all_possible_device_combination(false)));
// IE Class Query network
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassQueryNetworkTest,
::testing::ValuesIn(return_all_possible_device_combination()));
// IE Class Load network
INSTANTIATE_TEST_SUITE_P(
ie_plugin, IEClassLoadNetworkTest,
::testing::ValuesIn(return_all_possible_device_combination()));
} // namespace

36
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/core_threading_tests.cpp
View File

@ -1,36 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <behavior/plugin/core_threading.hpp>
#include "api_conformance_helpers.hpp"
using namespace ov::test::conformance;
namespace {
const Params coreThreadingParams[] = {
std::tuple<Device, Config>{ ov::test::utils::DEVICE_HETERO, generate_configs(ov::test::utils::DEVICE_HETERO).front() },
std::tuple<Device, Config>{ ov::test::utils::DEVICE_MULTI, generate_configs(ov::test::utils::DEVICE_MULTI).front() },
std::tuple<Device, Config>{ ov::test::utils::DEVICE_AUTO, generate_configs(ov::test::utils::DEVICE_AUTO).front() },
std::tuple<Device, Config>{ ov::test::utils::DEVICE_BATCH, generate_configs(ov::test::utils::DEVICE_BATCH).front() },
};
INSTANTIATE_TEST_SUITE_P(ie_plugin_, CoreThreadingTests,
testing::ValuesIn(coreThreadingParams),
CoreThreadingTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin, CoreThreadingTests,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(Config{{ CONFIG_KEY(PERF_COUNT), CONFIG_VALUE(YES) }})),
CoreThreadingTests::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin, CoreThreadingTestsWithIterations,
testing::Combine(testing::ValuesIn(coreThreadingParams),
testing::Values(4),
testing::Values(50),
testing::Values(ModelClass::Default)),
CoreThreadingTestsWithIterations::getTestCaseName);
} // namespace

33
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/life_time.cpp
View File

@ -1,33 +0,0 @@
// Copyright (C) 2018-2023 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<std::vector<int >> 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(ie_plugin, HoldersTest,
::testing::Combine(
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::ValuesIn(orders)),
HoldersTest::getTestCaseName);
} // namespace

66
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/set_preprocess.cpp
View File

@ -1,66 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "behavior/plugin/set_preprocess.hpp"
#include "api_conformance_helpers.hpp"
namespace {
using namespace BehaviorTestsDefinitions;
using namespace ov::test::conformance;
const std::vector<InferenceEngine::Precision> netPrecisionsPreprocess = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::FP16
};
INSTANTIATE_TEST_SUITE_P(ie_plugin, InferRequestPreprocessTest,
::testing::Combine(
::testing::ValuesIn(netPrecisionsPreprocess),
::testing::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestPreprocessTest::getTestCaseName);
const std::vector<InferenceEngine::Precision> ioPrecisionsPreprocess = {
InferenceEngine::Precision::FP32,
InferenceEngine::Precision::U8
};
const std::vector<InferenceEngine::Layout> netLayoutsPreprocess = {
InferenceEngine::Layout::NCHW,
// InferenceEngine::Layout::NHWC
};
const std::vector<InferenceEngine::Layout> ioLayoutsPreprocess = {
InferenceEngine::Layout::NCHW,
InferenceEngine::Layout::NHWC
};
INSTANTIATE_TEST_SUITE_P(ie_plugin, InferRequestPreprocessConversionTest,
::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::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestPreprocessConversionTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(ie_plugin, InferRequestPreprocessDynamicallyInSetBlobTest,
::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::ValuesIn(return_all_possible_device_combination()),
::testing::Values(ie_config)),
InferRequestPreprocessDynamicallyInSetBlobTest::getTestCaseName);
} // namespace

13
src/tests/functional/plugin/conformance/test_runner/api_conformance_runner/src/behavior/plugin/version.cpp
View File

@ -1,13 +0,0 @@
// Copyright (C) 2018-2023 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(ie_plugin, VersionTest,
::testing::ValuesIn(ov::test::conformance::return_all_possible_device_combination()),
VersionTest::getTestCaseName);
} // namespace