From 7c4b7355e6b9c07a92bc6a67988f8c099c90469f Mon Sep 17 00:00:00 2001 From: Oleg Pipikin Date: Thu, 17 Nov 2022 08:48:45 +0100 Subject: [PATCH] Delete serialization tests from ieFuncTests (#13804) * Delete serialization tests from ieFuncTests * Extend visitor tests to improve coverage Co-authored-by: Ilya Churaev --- src/core/tests/visitors/op/avg_pool.cpp | 29 ++ src/core/tests/visitors/op/convert_like.cpp | 27 ++ .../visitors/op/deformable_psroi_pooling.cpp | 39 +++ .../visitors/op/embedding_segments_sum.cpp | 33 +++ .../visitors/op/embeddingbag_offsetssum.cpp | 31 +++ .../visitors/op/embeddingbag_packedsum.cpp | 13 + src/core/tests/visitors/op/gru_cell.cpp | 36 ++- src/core/tests/visitors/op/lstm_cell.cpp | 36 +++ src/core/tests/visitors/op/multiclass_nms.cpp | 28 +- src/core/tests/visitors/op/prior_box.cpp | 48 ++++ src/core/tests/visitors/op/rnn_cell.cpp | 22 ++ .../tests/visitors/op/scatter_nd_update.cpp | 28 ++ src/core/tests/visitors/op/scatter_update.cpp | 2 + src/core/tests/visitors/op/slice.cpp | 2 + src/core/tests/visitors/op/swish.cpp | 33 ++- .../ir/tests/frontend_test_basic.cpp | 85 ++++++ .../tests/tensor_iterator_deserialization.cpp | 250 ++++++++++++++++++ .../serialization/core_config.cpp | 8 - .../serialization/single_layer/activation.cpp | 112 -------- .../serialization/single_layer/batch_norm.cpp | 55 ---- .../single_layer/batch_to_space.cpp | 72 ----- .../single_layer/binary_convolution.cpp | 63 ----- .../serialization/single_layer/broadcast.cpp | 33 --- .../serialization/single_layer/clamp.cpp | 34 --- .../single_layer/comparison_ops.hpp | 16 -- .../serialization/single_layer/constant.cpp | 56 ---- .../serialization/single_layer/conversion.cpp | 44 --- .../single_layer/convert_color_i420.cpp | 33 --- .../single_layer/convert_color_nv12.cpp | 33 --- .../single_layer/convolution.cpp | 62 ----- .../single_layer/convolution_backprop.cpp | 58 ---- .../serialization/single_layer/ctc_loss.cpp | 43 --- .../single_layer/deformable_convolution.cpp | 74 ------ .../single_layer/deformable_psroi_pooling.cpp | 35 --- .../single_layer/depth_to_space.cpp | 40 --- .../single_layer/detection_output.cpp | 74 ------ .../single_layer/elementwise.cpp | 85 ------ .../embedding_bag_offsets_sum.cpp | 48 ---- .../single_layer/embedding_bag_packed_sum.cpp | 42 --- .../single_layer/embedding_segments_sum.cpp | 50 ---- .../serialization/single_layer/equal.cpp | 63 ----- .../single_layer/extractimagepatches.cpp | 43 --- .../single_layer/gather_tree.cpp | 41 --- .../serialization/single_layer/greater.cpp | 63 ----- .../serialization/single_layer/greater_eq.cpp | 63 ----- .../serialization/single_layer/grn.cpp | 35 --- .../single_layer/group_convolution.cpp | 55 ---- .../group_convolution_backprop_data.cpp | 60 ----- .../serialization/single_layer/less.cpp | 63 ----- .../serialization/single_layer/less_eq.cpp | 63 ----- .../serialization/single_layer/logical.cpp | 84 ------ .../serialization/single_layer/matrix_nms.cpp | 69 ----- .../single_layer/minimum_maximum.cpp | 52 ---- .../single_layer/multiclass_nms.cpp | 120 --------- .../serialization/single_layer/mvn.cpp | 74 ------ .../single_layer/non_max_suppression.cpp | 57 ---- .../serialization/single_layer/nonzero.cpp | 34 --- .../single_layer/normalize_l2.cpp | 42 --- .../serialization/single_layer/not_equal.cpp | 63 ----- .../serialization/single_layer/one_hot.cpp | 39 --- .../serialization/single_layer/pad.cpp | 40 --- .../serialization/single_layer/pooling.cpp | 92 ------- .../serialization/single_layer/prelu.cpp | 43 --- .../serialization/single_layer/prior_box.cpp | 103 -------- .../single_layer/prior_box_clustered.cpp | 82 ------ .../serialization/single_layer/reduce_ops.cpp | 177 ------------- .../single_layer/region_yolo.cpp | 49 ---- .../serialization/single_layer/reshape.cpp | 35 --- .../serialization/single_layer/result.cpp | 34 --- .../single_layer/scatter_elements_update.cpp | 51 ---- .../single_layer/scatter_nd_update.cpp | 50 ---- .../single_layer/scatter_update.cpp | 51 ---- .../serialization/single_layer/select.cpp | 41 --- .../single_layer/shuffle_channels.cpp | 49 ---- .../serialization/single_layer/slice.cpp | 131 --------- .../single_layer/space_to_batch.cpp | 38 --- .../single_layer/space_to_depth.cpp | 45 ---- .../serialization/single_layer/split.cpp | 39 --- .../serialization/single_layer/squeeze.cpp | 46 ---- .../single_layer/tensor_iterator.cpp | 47 ---- .../serialization/single_layer/transpose.cpp | 71 ----- .../serialization/single_layer/unsqueeze.cpp | 46 ---- .../single_layer/variadic_split.cpp | 39 --- 83 files changed, 737 insertions(+), 3757 deletions(-) create mode 100644 src/core/tests/visitors/op/convert_like.cpp create mode 100644 src/core/tests/visitors/op/scatter_nd_update.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/core_config.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/activation.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/batch_norm.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/batch_to_space.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/binary_convolution.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/broadcast.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/clamp.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/comparison_ops.hpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/constant.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/conversion.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/convert_color_i420.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/convert_color_nv12.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/convolution.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/convolution_backprop.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/ctc_loss.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/deformable_convolution.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/deformable_psroi_pooling.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/depth_to_space.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/detection_output.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/elementwise.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/embedding_bag_offsets_sum.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/embedding_bag_packed_sum.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/embedding_segments_sum.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/equal.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/extractimagepatches.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/gather_tree.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/greater.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/greater_eq.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/grn.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/group_convolution.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/group_convolution_backprop_data.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/less.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/less_eq.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/logical.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/matrix_nms.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/minimum_maximum.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/multiclass_nms.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/mvn.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/non_max_suppression.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/nonzero.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/normalize_l2.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/not_equal.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/one_hot.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/pad.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/pooling.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/prelu.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/prior_box.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/prior_box_clustered.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/reduce_ops.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/region_yolo.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/reshape.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/result.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/scatter_elements_update.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/scatter_nd_update.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/scatter_update.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/select.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/shuffle_channels.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/slice.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/space_to_batch.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/space_to_depth.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/split.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/squeeze.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/tensor_iterator.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/transpose.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/unsqueeze.cpp delete mode 100644 src/tests/functional/inference_engine/serialization/single_layer/variadic_split.cpp diff --git a/src/core/tests/visitors/op/avg_pool.cpp b/src/core/tests/visitors/op/avg_pool.cpp index 25787eadb1e..9f2945c2ac9 100644 --- a/src/core/tests/visitors/op/avg_pool.cpp +++ b/src/core/tests/visitors/op/avg_pool.cpp @@ -26,6 +26,35 @@ TEST(attributes, avg_pool_op) { auto rounding_mode = op::RoundingType::FLOOR; auto auto_pad = op::PadType::EXPLICIT; + auto avg_pool = + make_shared(data, strides, pads_begin, pads_end, kernel, exclude_pad, rounding_mode, auto_pad); + + avg_pool->set_pads_begin(pads_begin); + avg_pool->set_pads_end(pads_end); + + NodeBuilder builder(avg_pool, {data}); + auto g_avg_pool = ov::as_type_ptr(builder.create()); + + EXPECT_EQ(g_avg_pool->get_strides(), avg_pool->get_strides()); + EXPECT_EQ(g_avg_pool->get_pads_begin(), avg_pool->get_pads_begin()); + EXPECT_EQ(g_avg_pool->get_pads_end(), avg_pool->get_pads_end()); + EXPECT_EQ(g_avg_pool->get_kernel(), avg_pool->get_kernel()); + EXPECT_EQ(g_avg_pool->get_rounding_type(), avg_pool->get_rounding_type()); + EXPECT_EQ(g_avg_pool->get_auto_pad(), avg_pool->get_auto_pad()); +} + +TEST(attributes, avg_pool_op_valid) { + NodeBuilder::get_ops().register_factory(); + auto data = make_shared(element::f32, Shape{64, 3, 5}); + + auto strides = Strides{2}; + auto pads_begin = Shape{1}; + auto pads_end = Shape{1}; + auto kernel = Shape{1}; + bool exclude_pad = false; + auto rounding_mode = op::RoundingType::FLOOR; + auto auto_pad = op::PadType::VALID; + auto avg_pool = make_shared(data, strides, pads_begin, pads_end, kernel, exclude_pad, rounding_mode, auto_pad); diff --git a/src/core/tests/visitors/op/convert_like.cpp b/src/core/tests/visitors/op/convert_like.cpp new file mode 100644 index 00000000000..930b40ee7de --- /dev/null +++ b/src/core/tests/visitors/op/convert_like.cpp @@ -0,0 +1,27 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "gtest/gtest.h" +#include "ngraph/ngraph.hpp" +#include "ngraph/op/util/attr_types.hpp" +#include "ngraph/opsets/opset1.hpp" +#include "util/visitor.hpp" + +using namespace std; +using namespace ngraph; +using ngraph::test::NodeBuilder; +using ngraph::test::ValueMap; + +TEST(attributes, convert_like_op) { + NodeBuilder::get_ops().register_factory(); + auto data = make_shared(element::i64, Shape{1, 2, 3}); + auto like = make_shared(element::i64, Shape{1, 2, 3}); + + auto convertLike = make_shared(data, like); + NodeBuilder builder(convertLike, {data, like}); + auto g_convertLike = ov::as_type_ptr(builder.create()); + + const auto expected_attr_count = 0; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); +} diff --git a/src/core/tests/visitors/op/deformable_psroi_pooling.cpp b/src/core/tests/visitors/op/deformable_psroi_pooling.cpp index f3a6632e2c9..a5b8a6f63a6 100644 --- a/src/core/tests/visitors/op/deformable_psroi_pooling.cpp +++ b/src/core/tests/visitors/op/deformable_psroi_pooling.cpp @@ -49,3 +49,42 @@ TEST(attributes, deformable_psroi_pooling_op) { EXPECT_EQ(g_op->get_trans_std(), op->get_trans_std()); EXPECT_EQ(g_op->get_part_size(), op->get_part_size()); } + +TEST(attributes, deformable_psroi_pooling_op2) { + NodeBuilder::get_ops().register_factory(); + auto input = make_shared(element::f32, Shape{2, 16, 67, 32}); + auto coords = make_shared(element::f32, Shape{300, 5}); + auto offset = make_shared(element::i64, Shape{300, 2, 2, 2}); + + const int output_dim = 4; + const float spatial_scale = 0.0625; + const int group_size = 2; + string mode = "bilinear_deformable"; + const int spatial_bins_x = 2; + const int spatial_bins_y = 3; + const float trans_std = 0.1; + const int part_size = 3; + + auto op = make_shared(input, + coords, + offset, + output_dim, + spatial_scale, + group_size, + mode, + spatial_bins_x, + spatial_bins_y, + trans_std, + part_size); + NodeBuilder builder(op, {input, coords, offset}); + auto g_op = ov::as_type_ptr(builder.create()); + + EXPECT_EQ(g_op->get_output_dim(), op->get_output_dim()); + EXPECT_EQ(g_op->get_spatial_scale(), op->get_spatial_scale()); + EXPECT_EQ(g_op->get_group_size(), op->get_group_size()); + EXPECT_EQ(g_op->get_mode(), op->get_mode()); + EXPECT_EQ(g_op->get_spatial_bins_x(), op->get_spatial_bins_x()); + EXPECT_EQ(g_op->get_spatial_bins_y(), op->get_spatial_bins_y()); + EXPECT_EQ(g_op->get_trans_std(), op->get_trans_std()); + EXPECT_EQ(g_op->get_part_size(), op->get_part_size()); +} diff --git a/src/core/tests/visitors/op/embedding_segments_sum.cpp b/src/core/tests/visitors/op/embedding_segments_sum.cpp index c74a9483418..d20f586436e 100644 --- a/src/core/tests/visitors/op/embedding_segments_sum.cpp +++ b/src/core/tests/visitors/op/embedding_segments_sum.cpp @@ -35,3 +35,36 @@ TEST(visitor_without_attribute, embedding_segments_sum_op) { const auto expected_attr_count = 0; EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); } + +TEST(visitor_without_attribute, embedding_segments_sum_op2) { + NodeBuilder::get_ops().register_factory(); + auto emb_table = make_shared(element::f32, Shape{5, 2, 3}); + + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto default_index = make_shared(element::i64, Shape{}); + + auto ess = make_shared(emb_table, indices, segment_ids, num_segments, default_index); + NodeBuilder builder(ess, {emb_table, indices, segment_ids, num_segments, default_index}); + EXPECT_NO_THROW(auto g_ess = ov::as_type_ptr(builder.create())); + + const auto expected_attr_count = 0; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); +} + +TEST(visitor_without_attribute, embedding_segments_sum_op3) { + NodeBuilder::get_ops().register_factory(); + auto emb_table = make_shared(element::f32, Shape{5, 2, 3}); + + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + + auto ess = make_shared(emb_table, indices, segment_ids, num_segments); + NodeBuilder builder(ess, {emb_table, indices, segment_ids, num_segments}); + EXPECT_NO_THROW(auto g_ess = ov::as_type_ptr(builder.create())); + + const auto expected_attr_count = 0; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); +} diff --git a/src/core/tests/visitors/op/embeddingbag_offsetssum.cpp b/src/core/tests/visitors/op/embeddingbag_offsetssum.cpp index 343717af285..ca4f5d9bf63 100644 --- a/src/core/tests/visitors/op/embeddingbag_offsetssum.cpp +++ b/src/core/tests/visitors/op/embeddingbag_offsetssum.cpp @@ -30,3 +30,34 @@ TEST(visitor_without_attribute, embedding_bag_offsets_sum_op) { const auto expected_attr_count = 0; EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); } + +TEST(visitor_without_attribute, embedding_bag_offsets_sum_op2) { + NodeBuilder::get_ops().register_factory(); + auto emb_table = make_shared(element::f32, Shape{5, 2, 3}); + + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); + + auto ebos = make_shared(emb_table, indices, offsets, default_index); + NodeBuilder builder(ebos, {emb_table, indices, offsets, default_index}); + EXPECT_NO_THROW(auto g_ebos = ov::as_type_ptr(builder.create())); + + const auto expected_attr_count = 0; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); +} + +TEST(visitor_without_attribute, embedding_bag_offsets_sum_op3) { + NodeBuilder::get_ops().register_factory(); + auto emb_table = make_shared(element::f32, Shape{5, 2, 3}); + + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{4}); + + auto ebos = make_shared(emb_table, indices, offsets); + NodeBuilder builder(ebos, {emb_table, indices, offsets}); + EXPECT_NO_THROW(auto g_ebos = ov::as_type_ptr(builder.create())); + + const auto expected_attr_count = 0; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); +} diff --git a/src/core/tests/visitors/op/embeddingbag_packedsum.cpp b/src/core/tests/visitors/op/embeddingbag_packedsum.cpp index 0b1fddb8372..d27c91451aa 100644 --- a/src/core/tests/visitors/op/embeddingbag_packedsum.cpp +++ b/src/core/tests/visitors/op/embeddingbag_packedsum.cpp @@ -26,3 +26,16 @@ TEST(visitor_without_attribute, embedding_bag_packed_sum_op) { const auto expected_attr_count = 0; EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); } + +TEST(visitor_without_attribute, embedding_bag_packed_sum_op2) { + NodeBuilder::get_ops().register_factory(); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{3, 4}); + + auto ebps = make_shared(emb_table, indices); + NodeBuilder builder(ebps, {emb_table, indices}); + EXPECT_NO_THROW(auto g_ebps = ov::as_type_ptr(builder.create())); + + const auto expected_attr_count = 0; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); +} diff --git a/src/core/tests/visitors/op/gru_cell.cpp b/src/core/tests/visitors/op/gru_cell.cpp index f0d12bc1ffa..51310e27c13 100644 --- a/src/core/tests/visitors/op/gru_cell.cpp +++ b/src/core/tests/visitors/op/gru_cell.cpp @@ -19,7 +19,6 @@ using ngraph::test::ValueMap; TEST(attributes, gru_cell_op) { NodeBuilder::get_ops().register_factory(); auto X = make_shared(element::f32, Shape{2, 3}); - auto H = make_shared(element::f32, Shape{2, 3}); auto W = make_shared(element::f32, Shape{9, 3}); auto R = make_shared(element::f32, Shape{9, 3}); const auto initial_hidden_state = make_shared(element::f32, Shape{2, 3}); @@ -49,3 +48,38 @@ TEST(attributes, gru_cell_op) { EXPECT_EQ(g_gru_cell->get_clip(), gru_cell->get_clip()); EXPECT_EQ(g_gru_cell->get_linear_before_reset(), gru_cell->get_linear_before_reset()); } + +TEST(attributes, gru_cell_op2) { + NodeBuilder::get_ops().register_factory(); + auto X = make_shared(element::f32, Shape{2, 3}); + auto W = make_shared(element::f32, Shape{9, 3}); + auto R = make_shared(element::f32, Shape{9, 3}); + const auto initial_hidden_state = make_shared(element::f32, Shape{2, 3}); + auto B = make_shared(element::f32, Shape{9}); + + const auto hidden_size = 3; + const std::vector activations = {"tanh", "sigmoid"}; + auto activations_alpha = std::vector{1.0, 1.5}; + auto activations_beta = std::vector{2.0, 1.0}; + const float clip = 0.5f; + const auto gru_cell = make_shared(X, + initial_hidden_state, + W, + R, + B, + hidden_size, + activations, + activations_alpha, + activations_beta, + clip, + false); + NodeBuilder builder(gru_cell, {X, initial_hidden_state, W, R, B}); + auto g_gru_cell = ov::as_type_ptr(builder.create()); + + EXPECT_EQ(g_gru_cell->get_hidden_size(), gru_cell->get_hidden_size()); + EXPECT_EQ(g_gru_cell->get_activations(), gru_cell->get_activations()); + EXPECT_EQ(g_gru_cell->get_activations_alpha(), gru_cell->get_activations_alpha()); + EXPECT_EQ(g_gru_cell->get_activations_beta(), gru_cell->get_activations_beta()); + EXPECT_EQ(g_gru_cell->get_clip(), gru_cell->get_clip()); + EXPECT_EQ(g_gru_cell->get_linear_before_reset(), gru_cell->get_linear_before_reset()); +} diff --git a/src/core/tests/visitors/op/lstm_cell.cpp b/src/core/tests/visitors/op/lstm_cell.cpp index c572ac5cb7d..5d15f4f7566 100644 --- a/src/core/tests/visitors/op/lstm_cell.cpp +++ b/src/core/tests/visitors/op/lstm_cell.cpp @@ -87,3 +87,39 @@ TEST(attributes, lstm_cell_v4_op) { EXPECT_EQ(g_lstm_cell->get_activations_beta(), lstm_cell->get_activations_beta()); EXPECT_EQ(g_lstm_cell->get_clip(), lstm_cell->get_clip()); } + +TEST(attributes, lstm_cell_v4_op2) { + NodeBuilder::get_ops().register_factory(); + auto X = make_shared(element::f32, Shape{2, 3}); + auto H = make_shared(element::f32, Shape{2, 3}); + auto W = make_shared(element::f32, Shape{12, 3}); + auto R = make_shared(element::f32, Shape{12, 3}); + const auto initial_hidden_state = make_shared(element::f32, Shape{2, 3}); + const auto initial_cell_state = make_shared(element::f32, Shape{2, 3}); + auto B = make_shared(element::f32, Shape{12}); + + const auto hidden_size = 3; + const std::vector activations = {"tanh", "sigmoid", "tanh"}; + auto activations_alpha = std::vector{1.0, 1.5}; + auto activations_beta = std::vector{2.0, 1.0}; + const float clip = 0.5f; + const auto lstm_cell = make_shared(X, + initial_hidden_state, + initial_cell_state, + W, + R, + B, + hidden_size, + activations, + activations_alpha, + activations_beta, + clip); + NodeBuilder builder(lstm_cell, {X, initial_hidden_state, initial_cell_state, W, R, B}); + auto g_lstm_cell = ov::as_type_ptr(builder.create()); + + EXPECT_EQ(g_lstm_cell->get_hidden_size(), lstm_cell->get_hidden_size()); + EXPECT_EQ(g_lstm_cell->get_activations(), lstm_cell->get_activations()); + EXPECT_EQ(g_lstm_cell->get_activations_alpha(), lstm_cell->get_activations_alpha()); + EXPECT_EQ(g_lstm_cell->get_activations_beta(), lstm_cell->get_activations_beta()); + EXPECT_EQ(g_lstm_cell->get_clip(), lstm_cell->get_clip()); +} diff --git a/src/core/tests/visitors/op/multiclass_nms.cpp b/src/core/tests/visitors/op/multiclass_nms.cpp index 70d3a21b1ef..303a441d01d 100644 --- a/src/core/tests/visitors/op/multiclass_nms.cpp +++ b/src/core/tests/visitors/op/multiclass_nms.cpp @@ -165,4 +165,30 @@ TEST(attributes, multiclass_nms_v9_op_default_attributes) { EXPECT_EQ(g_nms_attrs.background_class, nms_attrs.background_class); EXPECT_EQ(g_nms_attrs.nms_eta, nms_attrs.nms_eta); EXPECT_EQ(g_nms_attrs.normalized, nms_attrs.normalized); -} \ No newline at end of file +} + +TEST(attributes, multiclass_nms_v9_op_default_attributes2) { + NodeBuilder::get_ops().register_factory(); + auto boxes = make_shared(element::f32, Shape{3, 2, 4}); + auto scores = make_shared(element::f32, Shape{3, 3, 2}); + + auto nms = make_shared(boxes, scores, opset9::MulticlassNms::Attributes()); + NodeBuilder builder(nms, {boxes, scores}); + auto g_nms = ov::as_type_ptr(builder.create()); + const auto expected_attr_count = 10; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); + + auto& g_nms_attrs = g_nms->get_attrs(); + auto& nms_attrs = nms->get_attrs(); + + EXPECT_EQ(g_nms_attrs.sort_result_type, nms_attrs.sort_result_type); + EXPECT_EQ(g_nms_attrs.sort_result_across_batch, nms_attrs.sort_result_across_batch); + EXPECT_EQ(g_nms_attrs.output_type, nms_attrs.output_type); + EXPECT_EQ(g_nms_attrs.nms_top_k, nms_attrs.nms_top_k); + EXPECT_EQ(g_nms_attrs.keep_top_k, nms_attrs.keep_top_k); + EXPECT_EQ(g_nms_attrs.iou_threshold, nms_attrs.iou_threshold); + EXPECT_EQ(g_nms_attrs.score_threshold, nms_attrs.score_threshold); + EXPECT_EQ(g_nms_attrs.background_class, nms_attrs.background_class); + EXPECT_EQ(g_nms_attrs.nms_eta, nms_attrs.nms_eta); + EXPECT_EQ(g_nms_attrs.normalized, nms_attrs.normalized); +} diff --git a/src/core/tests/visitors/op/prior_box.cpp b/src/core/tests/visitors/op/prior_box.cpp index 502309064ce..d80a22e5db3 100644 --- a/src/core/tests/visitors/op/prior_box.cpp +++ b/src/core/tests/visitors/op/prior_box.cpp @@ -10,6 +10,7 @@ #include "ngraph/opsets/opset4.hpp" #include "ngraph/opsets/opset5.hpp" #include "ngraph/opsets/opset8.hpp" +#include "ngraph_functions/builders.hpp" #include "util/visitor.hpp" using namespace std; @@ -147,3 +148,50 @@ TEST(attributes, prior_box_v8_op) { EXPECT_EQ(g_prior_box_attrs.min_max_aspect_ratios_order, prior_box_attrs.min_max_aspect_ratios_order); EXPECT_EQ(g_prior_box->has_evaluate(), prior_box->has_evaluate()); } + +TEST(attributes, prior_box_v8_op2) { + NodeBuilder::get_ops().register_factory(); + + auto params = ngraph::builder::makeParams(ov::element::Type_t::i32, {{128, 128}, {32, 32}}); + auto shape_of_1 = std::make_shared(params[0]); + auto shape_of_2 = std::make_shared(params[1]); + + op::v8::PriorBox::Attributes attrs; + attrs.min_size = vector{16.f, 32.f}; + attrs.max_size = vector{256.f, 512.f}; + attrs.aspect_ratio = vector{0.66f, 1.56f}; + attrs.density = vector{0.55f}; + attrs.fixed_ratio = vector{0.88f}; + attrs.fixed_size = vector{1.25f}; + attrs.clip = true; + attrs.flip = false; + attrs.step = 1.0f; + attrs.offset = 0.0f; + attrs.variance = vector{2.22f, 3.14f}; + attrs.scale_all_sizes = true; + attrs.min_max_aspect_ratios_order = false; + + auto prior_box = make_shared(shape_of_1, shape_of_2, attrs); + NodeBuilder builder(prior_box, {shape_of_1, shape_of_2}); + auto g_prior_box = ov::as_type_ptr(builder.create()); + + const auto prior_box_attrs = prior_box->get_attrs(); + const auto g_prior_box_attrs = g_prior_box->get_attrs(); + + const auto expected_attr_count = 13; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); + EXPECT_EQ(g_prior_box_attrs.min_size, prior_box_attrs.min_size); + EXPECT_EQ(g_prior_box_attrs.max_size, prior_box_attrs.max_size); + EXPECT_EQ(g_prior_box_attrs.aspect_ratio, prior_box_attrs.aspect_ratio); + EXPECT_EQ(g_prior_box_attrs.density, prior_box_attrs.density); + EXPECT_EQ(g_prior_box_attrs.fixed_ratio, prior_box_attrs.fixed_ratio); + EXPECT_EQ(g_prior_box_attrs.fixed_size, prior_box_attrs.fixed_size); + EXPECT_EQ(g_prior_box_attrs.clip, prior_box_attrs.clip); + EXPECT_EQ(g_prior_box_attrs.flip, prior_box_attrs.flip); + EXPECT_EQ(g_prior_box_attrs.step, prior_box_attrs.step); + EXPECT_EQ(g_prior_box_attrs.offset, prior_box_attrs.offset); + EXPECT_EQ(g_prior_box_attrs.variance, prior_box_attrs.variance); + EXPECT_EQ(g_prior_box_attrs.scale_all_sizes, prior_box_attrs.scale_all_sizes); + EXPECT_EQ(g_prior_box_attrs.min_max_aspect_ratios_order, prior_box_attrs.min_max_aspect_ratios_order); + EXPECT_EQ(g_prior_box->has_evaluate(), prior_box->has_evaluate()); +} diff --git a/src/core/tests/visitors/op/rnn_cell.cpp b/src/core/tests/visitors/op/rnn_cell.cpp index 1a44fcd9fa0..c81c17b022c 100644 --- a/src/core/tests/visitors/op/rnn_cell.cpp +++ b/src/core/tests/visitors/op/rnn_cell.cpp @@ -62,3 +62,25 @@ TEST(attributes, rnn_cell_op_default_attributes) { EXPECT_EQ(g_rnn_cell->get_activations_alpha(), rnn_cell->get_activations_alpha()); EXPECT_EQ(g_rnn_cell->get_activations_beta(), rnn_cell->get_activations_beta()); } + +TEST(attributes, rnn_cell_op_default_attributes2) { + NodeBuilder::get_ops().register_factory(); + auto X = make_shared(element::f32, Shape{2, 3}); + auto H = make_shared(element::f32, Shape{2, 3}); + auto W = make_shared(element::f32, Shape{3, 3}); + auto R = make_shared(element::f32, Shape{3, 3}); + auto B = make_shared(element::f32, Shape{3}); + + const size_t hidden_size = 3; + + auto rnn_cell = make_shared(X, H, W, R, B, hidden_size); + + NodeBuilder builder(rnn_cell, {X, H, W, R, B}); + auto g_rnn_cell = ov::as_type_ptr(builder.create()); + + EXPECT_EQ(g_rnn_cell->get_hidden_size(), rnn_cell->get_hidden_size()); + EXPECT_EQ(g_rnn_cell->get_clip(), rnn_cell->get_clip()); + EXPECT_EQ(g_rnn_cell->get_activations(), rnn_cell->get_activations()); + EXPECT_EQ(g_rnn_cell->get_activations_alpha(), rnn_cell->get_activations_alpha()); + EXPECT_EQ(g_rnn_cell->get_activations_beta(), rnn_cell->get_activations_beta()); +} diff --git a/src/core/tests/visitors/op/scatter_nd_update.cpp b/src/core/tests/visitors/op/scatter_nd_update.cpp new file mode 100644 index 00000000000..e70551ef69e --- /dev/null +++ b/src/core/tests/visitors/op/scatter_nd_update.cpp @@ -0,0 +1,28 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "gtest/gtest.h" +#include "ngraph/ngraph.hpp" +#include "ngraph/op/util/attr_types.hpp" +#include "ngraph/opsets/opset4.hpp" +#include "util/visitor.hpp" + +using namespace ngraph; +using ngraph::test::NodeBuilder; +using ngraph::test::ValueMap; + +TEST(attributes, scatter_nd_update) { + NodeBuilder::get_ops().register_factory(); + + auto data = std::make_shared(element::f32, Shape{1000, 256, 10, 15}); + auto indices = std::make_shared(element::i32, Shape{25, 125, 3}); + auto updates = std::make_shared(element::f32, Shape{25, 125, 15}); + + auto scatter = std::make_shared(data, indices, updates); + NodeBuilder builder(scatter, {data, indices, updates}); + EXPECT_NO_THROW(auto g_scatter = ov::as_type_ptr(builder.create())); + + const auto expected_attr_count = 0; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); +} diff --git a/src/core/tests/visitors/op/scatter_update.cpp b/src/core/tests/visitors/op/scatter_update.cpp index f722bd69c64..8dbf66914fa 100644 --- a/src/core/tests/visitors/op/scatter_update.cpp +++ b/src/core/tests/visitors/op/scatter_update.cpp @@ -30,6 +30,8 @@ TEST(attributes, scatter_update_op) { auto op = make_shared(R, I, U, A); NodeBuilder builder(op, {R, I, U, A}); + EXPECT_NO_THROW(auto g_op = ov::as_type_ptr(builder.create())); + const auto expected_attr_count = 0; EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); diff --git a/src/core/tests/visitors/op/slice.cpp b/src/core/tests/visitors/op/slice.cpp index dd667b14c68..6be642f541c 100644 --- a/src/core/tests/visitors/op/slice.cpp +++ b/src/core/tests/visitors/op/slice.cpp @@ -21,6 +21,7 @@ TEST(attributes, slice_op_no_axes) { const auto op = make_shared(data, start, stop, step); NodeBuilder builder(op, {data, start, stop, step}); + EXPECT_NO_THROW(auto g_op = ov::as_type_ptr(builder.create())); const auto expected_attr_count = 0; EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); @@ -36,6 +37,7 @@ TEST(attributes, slice_op_with_axes) { const auto op = make_shared(data, start, stop, step, axes); NodeBuilder builder(op, {data, start, stop, step, axes}); + EXPECT_NO_THROW(auto g_op = ov::as_type_ptr(builder.create())); const auto expected_attr_count = 0; EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); diff --git a/src/core/tests/visitors/op/swish.cpp b/src/core/tests/visitors/op/swish.cpp index 87a72d0e0e0..c4ea08cb337 100644 --- a/src/core/tests/visitors/op/swish.cpp +++ b/src/core/tests/visitors/op/swish.cpp @@ -2,8 +2,35 @@ // SPDX-License-Identifier: Apache-2.0 // -#include "unary_ops.hpp" +#include "gtest/gtest.h" +#include "ngraph/opsets/opset4.hpp" +#include "util/visitor.hpp" -using Type = ::testing::Types>; +using namespace std; +using namespace ngraph; +using ngraph::test::NodeBuilder; -INSTANTIATE_TYPED_TEST_SUITE_P(visitor_without_atrribute, UnaryOperatorVisitor, Type, UnaryOperatorTypeName); +TEST(attributes, swish_op) { + NodeBuilder::get_ops().register_factory(); + const auto data = make_shared(element::f32, Shape{1, 2, 3}); + + const auto op = make_shared(data); + NodeBuilder builder(op, {data}); + EXPECT_NO_THROW(auto g_op = ov::as_type_ptr(builder.create())); + + const auto expected_attr_count = 0; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); +} + +TEST(attributes, swish_op2) { + NodeBuilder::get_ops().register_factory(); + const auto data = make_shared(element::f32, Shape{1, 2, 3}); + const auto beta = make_shared(element::f32, Shape{}); + + const auto op = make_shared(data, beta); + NodeBuilder builder(op, {data, beta}); + EXPECT_NO_THROW(auto g_op = ov::as_type_ptr(builder.create())); + + const auto expected_attr_count = 0; + EXPECT_EQ(builder.get_value_map_size(), expected_attr_count); +} diff --git a/src/frontends/ir/tests/frontend_test_basic.cpp b/src/frontends/ir/tests/frontend_test_basic.cpp index 269ed0b658f..248c3e4a523 100644 --- a/src/frontends/ir/tests/frontend_test_basic.cpp +++ b/src/frontends/ir/tests/frontend_test_basic.cpp @@ -1302,3 +1302,88 @@ TEST_F(IRFrontendTests, name_with_comma) { auto it = names.find(tensor_name); EXPECT_NE(it, names.end()); } + +TEST_F(IRFrontendTests, DetectionOutput) { + std::string testModel = R"V0G0N( + + + + + + + 1 + 60 + + + + + + + + 1 + 165 + + + + + + + + 1 + 1 + 60 + + + + + + + + 1 + 60 + + + 1 + 165 + + + 1 + 1 + 60 + + + + + 1 + 1 + 50 + 7 + + + + + + + 1 + 1 + 50 + 7 + + + + + + + + + + + + +)V0G0N"; + + std::shared_ptr model; + + ASSERT_NO_THROW(model = getWithIRFrontend(testModel)); + ASSERT_TRUE(!!model); +} diff --git a/src/frontends/ir/tests/tensor_iterator_deserialization.cpp b/src/frontends/ir/tests/tensor_iterator_deserialization.cpp index 74bfdd3f81a..ab7bcea95bd 100644 --- a/src/frontends/ir/tests/tensor_iterator_deserialization.cpp +++ b/src/frontends/ir/tests/tensor_iterator_deserialization.cpp @@ -1444,3 +1444,253 @@ TEST_F(IRFrontendTestsTensorIterator, tensor_iterator_negative_stride_opset4) { ASSERT_NO_THROW(model = core.read_model(xmlFileName, binFileName)); ASSERT_TRUE(!!model); } + +TEST_F(IRFrontendTestsTensorIterator, test1) { + std::string xmlModel = R"V0G0N( + + + + + + + + 1 + 128 + + + + + + + + 1 + 2 + 10 + + + + + + + + + + + + + + + + 1 + 2 + 10 + + + 1 + 128 + + + + + 1 + 2 + 128 + + + 1 + 128 + + + + + + + + + 1 + 128 + + + + + + + + 1 + 1 + 10 + + + + + + + + 1 + + + + + + + 1 + 1 + 10 + + + 1 + + + + + 1 + 10 + + + + + + + + 384 + 10 + + + + + + + + 384 + 128 + + + + + + + + 384 + + + + + + + + 1 + 10 + + + 1 + 128 + + + 384 + 10 + + + 384 + 128 + + + 384 + + + + + 1 + 128 + + + + + + + 1 + 128 + + + 1 + + + + + 1 + 1 + 128 + + + + + + + 1 + 1 + 128 + + + + + + + 1 + 128 + + + + + + + + + + + + + + + + + + + + + + + + 1 + 128 + + + + + + + 1 + 2 + 128 + + + + + + + + + + + + + )V0G0N"; + + std::vector buffer(213512, 0); + int64_t* int64Buffer = reinterpret_cast(buffer.data()); + int64Buffer[0] = 1; + + createTemporalModelFile(xmlModel, buffer); + std::shared_ptr model; + + ASSERT_NO_THROW(model = core.read_model(xmlFileName, binFileName)); + ASSERT_TRUE(!!model); +} diff --git a/src/tests/functional/inference_engine/serialization/core_config.cpp b/src/tests/functional/inference_engine/serialization/core_config.cpp deleted file mode 100644 index 5e7e7675443..00000000000 --- a/src/tests/functional/inference_engine/serialization/core_config.cpp +++ /dev/null @@ -1,8 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "functional_test_utils/core_config.hpp" - -void CoreConfiguration(LayerTestsUtils::LayerTestsCommon* test) { -} diff --git a/src/tests/functional/inference_engine/serialization/single_layer/activation.cpp b/src/tests/functional/inference_engine/serialization/single_layer/activation.cpp deleted file mode 100644 index e8d5d027d7f..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/activation.cpp +++ /dev/null @@ -1,112 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include "shared_test_classes/single_layer/activation.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; -using namespace ngraph::helpers; -namespace { -TEST_P(ActivationLayerTest, Serialize) { - Serialize(); -} -// Common params -const std::vector inputPrecisions = { - InferenceEngine::Precision::FP32 - // TODO: Fix Issue-27390 - // InferenceEngine::Precision::I16, - // InferenceEngine::Precision::U8 -}; - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16 -}; - -const std::map>> activationTypes = { - {Sigmoid, {}}, - {Tanh, {}}, - {Relu, {}}, - {Exp, {}}, - {Log, {}}, - {Sign, {}}, - {Abs, {}}, - {Clamp, {{-2.0f, 2.0f}}}, - {Negative, {}}, - {Acos, {}}, - {Acosh, {}}, - {Asin, {}}, - {Asinh, {}}, - {Atan, {}}, - {Atanh, {}}, - {Cos, {}}, - {Cosh, {}}, - {Floor, {}}, - {Sin, {}}, - {Sinh, {}}, - {Sqrt, {}}, - {Tan, {}}, - {Elu, {{0.1f}}}, - {Erf, {}}, - {HardSigmoid, {{0.2f, 0.5f}}}, - {Selu, {{1.6732f, 1.0507f}}}, - {Ceiling, {}}, - {Mish, {}}, - {HSwish, {}}, - {Swish, {{0.3f}}}, - {SoftPlus, {}}, - {HSigmoid, {}}, - {RoundHalfToEven, {}}, - {RoundHalfAwayFromZero, {}}, - {GeluErf, {}}, - {GeluTanh, {}} -}; - -const std::map>> activationParamTypes = { - {PReLu, {{-0.01f}}}, - {LeakyRelu, {{0.01f}}} -}; - -std::map, std::vector>> basic = { - {{1, 50}, {{}}}, - {{1, 128}, {{}}}, -}; - -std::map, std::vector>> preluBasic = { - {{1, 50}, {{1}, {50}}}, - {{1, 128}, {{1}, {128}}}, -}; - -const auto basicCases = ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(activationTypes)), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::ValuesIn(CommonTestUtils::combineParams(basic)), - ::testing::Values(CommonTestUtils::DEVICE_CPU) -); - -const auto basicPreluCases = ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(activationParamTypes)), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::ValuesIn(CommonTestUtils::combineParams(preluBasic)), - ::testing::Values(CommonTestUtils::DEVICE_CPU) -); - - -INSTANTIATE_TEST_SUITE_P(smoke_Activation_Basic, ActivationLayerTest, basicCases, ActivationLayerTest::getTestCaseName); -INSTANTIATE_TEST_SUITE_P(smoke_Activation_Basic_Prelu, ActivationLayerTest, basicPreluCases, ActivationLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_Activation_Basic, ActivationParamLayerTest, basicPreluCases, ActivationLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_Activation_Basic, ActivationDynamicLayerTest, basicCases, ActivationLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/batch_norm.cpp b/src/tests/functional/inference_engine/serialization/single_layer/batch_norm.cpp deleted file mode 100644 index 65275c77dfa..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/batch_norm.cpp +++ /dev/null @@ -1,55 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/batch_norm.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(BatchNormLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16 -}; - -const std::vector epsilon = { - 0.0, - 1e-6, - 1e-5, - 1e-4 -}; - -const std::vector> inputShapes = { - {1, 3}, - {2, 5}, - {1, 3, 10}, - {1, 3, 1, 1}, - {2, 5, 4, 4}, -}; - -const auto batchNormParams = testing::Combine( - testing::ValuesIn(epsilon), - testing::ValuesIn(netPrecisions), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Layout::ANY), - testing::Values(InferenceEngine::Layout::ANY), - testing::ValuesIn(inputShapes), - testing::Values(CommonTestUtils::DEVICE_CPU) -); - -INSTANTIATE_TEST_SUITE_P( - smoke_BatchNorm_Serialization, - BatchNormLayerTest, - batchNormParams, - BatchNormLayerTest::getTestCaseName -); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/batch_to_space.cpp b/src/tests/functional/inference_engine/serialization/single_layer/batch_to_space.cpp deleted file mode 100644 index 66e579e7b46..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/batch_to_space.cpp +++ /dev/null @@ -1,72 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/batch_to_space.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(BatchToSpaceLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP16}; - -const std::vector> block_shapes_4D = { - {1, 1, 2, 2}, - {1, 1, 4, 2} -}; - -const std::vector> crops_4D = { - {0, 0, 0, 0}, - {0, 0, 1, 0}, - {0, 0, 0, 1} -}; - -const auto batch_to_space_4D_params = ::testing::Combine( - ::testing::ValuesIn(block_shapes_4D), - ::testing::ValuesIn(crops_4D), - ::testing::ValuesIn(crops_4D), - ::testing::Values(std::vector{16, 1, 2, 2}), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -const std::vector> block_shapes_5D = { - {1, 1, 2, 1, 3}, - {1, 1, 4, 2, 2} -}; - -const std::vector> crops_5D = { - {0, 0, 0, 0, 0}, - {0, 0, 1, 0, 1}, - {0, 0, 0, 1, 1} -}; - -const auto batch_to_space_5D_params = ::testing::Combine( - ::testing::ValuesIn(block_shapes_5D), - ::testing::ValuesIn(crops_5D), - ::testing::ValuesIn(crops_5D), - ::testing::Values(std::vector{48, 1, 3, 4, 2}), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P( - smoke_BatchToSpace_Serialization_4D, BatchToSpaceLayerTest, - batch_to_space_4D_params, - BatchToSpaceLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P( - smoke_BatchToSpace_Serialization_5D, BatchToSpaceLayerTest, - batch_to_space_5D_params, - BatchToSpaceLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/binary_convolution.cpp b/src/tests/functional/inference_engine/serialization/single_layer/binary_convolution.cpp deleted file mode 100644 index 53cbc782a56..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/binary_convolution.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/binary_convolution.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(BinaryConvolutionLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP16}; -const std::vector> kernels = {{3, 5}}; -const std::vector> strides = {{1, 3}}; -const std::vector> padBegins = {{0, 3}}; -const std::vector> padEnds = {{0, 3}}; -const std::vector> dilations = {{3, 1}}; -const std::vector numOutChannels = {5}; -const std::vector pad_values = {0, 1}; - -const auto binConv2DParams_ExplicitPadding = ::testing::Combine( - ::testing::ValuesIn(kernels), ::testing::ValuesIn(strides), - ::testing::ValuesIn(padBegins), ::testing::ValuesIn(padEnds), - ::testing::ValuesIn(dilations), ::testing::ValuesIn(numOutChannels), - ::testing::Values(ngraph::op::PadType::EXPLICIT), - ::testing::ValuesIn(pad_values)); -const auto binConv2DParams_AutoPadValid = ::testing::Combine( - ::testing::ValuesIn(kernels), ::testing::ValuesIn(strides), - ::testing::Values(std::vector({0, 0})), - ::testing::Values(std::vector({0, 0})), - ::testing::ValuesIn(dilations), ::testing::ValuesIn(numOutChannels), - ::testing::Values(ngraph::op::PadType::VALID), - ::testing::ValuesIn(pad_values)); - -INSTANTIATE_TEST_SUITE_P( - smoke_BinaryConvolution2D_Serialization_ExplicitPadding, BinaryConvolutionLayerTest, - ::testing::Combine( - binConv2DParams_ExplicitPadding, ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({1, 3, 30, 30})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - BinaryConvolutionLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P( - smoke_BinaryConvolution2D__Serialization_AutoPadValid, BinaryConvolutionLayerTest, - ::testing::Combine( - binConv2DParams_AutoPadValid, ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({1, 3, 30, 30})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - BinaryConvolutionLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/broadcast.cpp b/src/tests/functional/inference_engine/serialization/single_layer/broadcast.cpp deleted file mode 100644 index 1056bcdf5ea..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/broadcast.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/broadcast.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(BroadcastLayerTest, Serialize) { Serialize(); } -const std::vector inputPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::I32, - InferenceEngine::Precision::BOOL}; - -// NUMPY MODE - -std::vector> inShapesNumpy = {{3, 1}, {1, 4, 1}}; - -std::vector> targetShapesNumpy = {{2, 3, 6}, {1, 4, 4}}; - -const auto numpyBroadcastParams1 = ::testing::Combine( - ::testing::Values(targetShapesNumpy[0]), - ::testing::Values(ngraph::AxisSet{}), // not used in numpy mode - ::testing::Values(ngraph::op::BroadcastType::NUMPY), - ::testing::Values(inShapesNumpy[0]), ::testing::ValuesIn(inputPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P(smoke_Broadcast1Serialization, BroadcastLayerTest, - numpyBroadcastParams1, - BroadcastLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/clamp.cpp b/src/tests/functional/inference_engine/serialization/single_layer/clamp.cpp deleted file mode 100644 index c62560da008..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/clamp.cpp +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/clamp.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(ClampLayerTest, Serialize) { - Serialize(); -} - -const std::vector> inShapes = { - {50}, {10, 10}, {1, 20, 20}, {2, 3, 50, 50}}; - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::I32}; - -const std::vector> intervals = { - {-20.1, -10.5}, {-10.0, 10.0}, {10.3, 20.4}}; - -INSTANTIATE_TEST_SUITE_P( - smoke_Clamp_Serialization, ClampLayerTest, - ::testing::Combine( - ::testing::ValuesIn(inShapes), - ::testing::ValuesIn(intervals), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - ClampLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/comparison_ops.hpp b/src/tests/functional/inference_engine/serialization/single_layer/comparison_ops.hpp deleted file mode 100644 index c7924168e66..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/comparison_ops.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/comparison.hpp" - -struct ComparisionOpsData { - const std::map, std::vector>> inputShapes; - const std::vector inputsPrecisions; - const std::vector secondInputTypes; - const std::map additional_config; - const ngraph::helpers::ComparisonTypes opType; - const InferenceEngine::Precision ieInputPrecision; - const InferenceEngine::Precision ieOutputPrecision; - const std::string deviceName; -}; diff --git a/src/tests/functional/inference_engine/serialization/single_layer/constant.cpp b/src/tests/functional/inference_engine/serialization/single_layer/constant.cpp deleted file mode 100644 index aa9fca52ad3..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/constant.cpp +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/constant.hpp" - -#include - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(ConstantLayerTest, Serialize) { - Serialize(); -} - -std::vector> shapes = { - {2, 2, 3}, - {3, 4, 1}, - {1, 1, 12}, -}; - -std::vector precisions = { - InferenceEngine::Precision::BIN, InferenceEngine::Precision::BF16, - InferenceEngine::Precision::FP16, InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP64, InferenceEngine::Precision::U4, - InferenceEngine::Precision::U8, InferenceEngine::Precision::U16, - InferenceEngine::Precision::U32, InferenceEngine::Precision::I4, - InferenceEngine::Precision::I8, InferenceEngine::Precision::I16, - InferenceEngine::Precision::I32, -}; - -std::vector data = {"1", "2", "3", "4", "5", "6", "7", "1", "2", "3", "4", "5"}; - -std::vector precisionsWithNegativeValues = { - InferenceEngine::Precision::BF16, InferenceEngine::Precision::FP16, - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP64, - InferenceEngine::Precision::I4, InferenceEngine::Precision::I8, - InferenceEngine::Precision::I16, InferenceEngine::Precision::I32, -}; - -std::vector dataWithNegativeValues = {"1", "-2", "3", "-4", "5", "-6", - "7", "-1", "2", "-3", "4", "-5"}; - -INSTANTIATE_TEST_SUITE_P(smoke_Constant_Serialization, ConstantLayerTest, - ::testing::Combine(::testing::ValuesIn(shapes), - ::testing::ValuesIn(precisions), ::testing::Values(data), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - ConstantLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_Constant_Serialization_with_negative_values, ConstantLayerTest, - ::testing::Combine(::testing::ValuesIn(shapes), - ::testing::ValuesIn(precisionsWithNegativeValues), - ::testing::Values(dataWithNegativeValues), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - ConstantLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/conversion.cpp b/src/tests/functional/inference_engine/serialization/single_layer/conversion.cpp deleted file mode 100644 index 2871f12478c..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/conversion.cpp +++ /dev/null @@ -1,44 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/conversion.hpp" - -#include - -using namespace LayerTestsDefinitions; - -namespace { -const std::vector conversionOpTypes = { - ngraph::helpers::ConversionTypes::CONVERT, - ngraph::helpers::ConversionTypes::CONVERT_LIKE, -}; - -const std::vector> inShape = {{1, 2, 3, 4}}; - -const std::vector precisions = { - InferenceEngine::Precision::BOOL, InferenceEngine::Precision::BIN, - InferenceEngine::Precision::U4, InferenceEngine::Precision::U8, - InferenceEngine::Precision::I4, InferenceEngine::Precision::I8, - InferenceEngine::Precision::U16, InferenceEngine::Precision::I16, - InferenceEngine::Precision::U32, InferenceEngine::Precision::I32, - InferenceEngine::Precision::U64, InferenceEngine::Precision::I64, - InferenceEngine::Precision::BF16, InferenceEngine::Precision::FP16, - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP64}; - -TEST_P(ConversionLayerTest, Serialize) { - Serialize(); -} - -INSTANTIATE_TEST_SUITE_P( - smoke_Serialization_ConversionLayerTest, ConversionLayerTest, - ::testing::Combine(::testing::ValuesIn(conversionOpTypes), - ::testing::Values(inShape), - ::testing::ValuesIn(precisions), - ::testing::ValuesIn(precisions), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - ConversionLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/convert_color_i420.cpp b/src/tests/functional/inference_engine/serialization/single_layer/convert_color_i420.cpp deleted file mode 100644 index 4b7695fcbba..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/convert_color_i420.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/convert_color_i420.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(ConvertColorI420LayerTest, Serialize) { - Serialize(); -} - -const std::vector inShapes_nhwc = { - {1, 10, 10, 1} -}; - -const std::vector inTypes = { - ov::element::u8, ov::element::f32 -}; - -const auto testCase_values = ::testing::Combine( - ::testing::ValuesIn(inShapes_nhwc), - ::testing::ValuesIn(inTypes), - ::testing::Bool(), - ::testing::Bool(), - ::testing::Values(CommonTestUtils::DEVICE_CPU) -); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, ConvertColorI420LayerTest, testCase_values, ConvertColorI420LayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/convert_color_nv12.cpp b/src/tests/functional/inference_engine/serialization/single_layer/convert_color_nv12.cpp deleted file mode 100644 index 3e236bca72d..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/convert_color_nv12.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/convert_color_nv12.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(ConvertColorNV12LayerTest, Serialize) { - Serialize(); - } - -const std::vector inShapes_nhwc = { - {1, 10, 10, 1} -}; - -const std::vector inTypes = { - ov::element::u8, ov::element::f32 -}; - -const auto testCase_values = ::testing::Combine( - ::testing::ValuesIn(inShapes_nhwc), - ::testing::ValuesIn(inTypes), - ::testing::Bool(), - ::testing::Bool(), - ::testing::Values(CommonTestUtils::DEVICE_CPU) -); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, ConvertColorNV12LayerTest, testCase_values, ConvertColorNV12LayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/convolution.cpp b/src/tests/functional/inference_engine/serialization/single_layer/convolution.cpp deleted file mode 100644 index 0526ad3c04b..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/convolution.cpp +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/convolution.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(ConvolutionLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I16, InferenceEngine::Precision::I32, - InferenceEngine::Precision::I64}; -const std::vector> kernels = {{3, 5}}; -const std::vector> strides = {{1, 3}}; -const std::vector> padBegins = {{0, 3}}; -const std::vector> padEnds = {{0, 3}}; -const std::vector> dilations = {{3, 1}}; -const std::vector numOutChannels = {5}; - -const auto conv2DParams_ExplicitPadding = ::testing::Combine( - ::testing::ValuesIn(kernels), ::testing::ValuesIn(strides), - ::testing::ValuesIn(padBegins), ::testing::ValuesIn(padEnds), - ::testing::ValuesIn(dilations), ::testing::ValuesIn(numOutChannels), - ::testing::Values(ngraph::op::PadType::EXPLICIT)); -const auto conv2DParams_AutoPadValid = ::testing::Combine( - ::testing::ValuesIn(kernels), ::testing::ValuesIn(strides), - ::testing::Values(std::vector({0, 0})), - ::testing::Values(std::vector({0, 0})), - ::testing::ValuesIn(dilations), ::testing::ValuesIn(numOutChannels), - ::testing::Values(ngraph::op::PadType::VALID)); - -INSTANTIATE_TEST_SUITE_P( - smoke_Convolution2D_Serialization_ExplicitPadding, ConvolutionLayerTest, - ::testing::Combine( - conv2DParams_ExplicitPadding, ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({1, 3, 30, 30})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - ConvolutionLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P( - smoke_Convolution2D__Serialization_AutoPadValid, ConvolutionLayerTest, - ::testing::Combine( - conv2DParams_AutoPadValid, ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({1, 3, 30, 30})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - ConvolutionLayerTest::getTestCaseName); -} // namespace \ No newline at end of file diff --git a/src/tests/functional/inference_engine/serialization/single_layer/convolution_backprop.cpp b/src/tests/functional/inference_engine/serialization/single_layer/convolution_backprop.cpp deleted file mode 100644 index 22aab12b53d..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/convolution_backprop.cpp +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/convolution_backprop_data.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(ConvolutionBackpropDataLayerTest, Serialize) { - Serialize(); -} - -const std::vector precisions = { - InferenceEngine::Precision::FP64, InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, InferenceEngine::Precision::BF16, - InferenceEngine::Precision::I8, InferenceEngine::Precision::I16, - InferenceEngine::Precision::I32, InferenceEngine::Precision::I64, - InferenceEngine::Precision::U8, InferenceEngine::Precision::U16, - InferenceEngine::Precision::U32, InferenceEngine::Precision::U64, -}; -const std::vector> kernels = {{3, 3}}; -const std::vector> strides = {{1, 1}}; -const std::vector> padBegins = {{0, 0}}; -const std::vector> padEnds = {{0, 0}}; -const std::vector> dilations = {{1, 1}}; -const std::vector> outPadding = {{}, {1, 1}}; -const std::vector numOutChannels = {8, 16}; -const std::vector pad_types = { - ngraph::op::PadType::EXPLICIT, ngraph::op::PadType::VALID, - ngraph::op::PadType::SAME_LOWER, ngraph::op::PadType::SAME_UPPER}; -const auto inputShapes = std::vector({1, 16, 20, 20}); -const std::vector> emptyOutputShape = {{}}; - -const auto convolutionBackpropData2DParams = ::testing::Combine( - ::testing::ValuesIn(kernels), ::testing::ValuesIn(strides), - ::testing::ValuesIn(padBegins), ::testing::ValuesIn(padEnds), - ::testing::ValuesIn(dilations), ::testing::ValuesIn(numOutChannels), - ::testing::ValuesIn(pad_types), ::testing::ValuesIn(outPadding)); - -INSTANTIATE_TEST_SUITE_P( - smoke_convolutionBackpropData2D_Serialization, ConvolutionBackpropDataLayerTest, - ::testing::Combine( - convolutionBackpropData2DParams, - ::testing::ValuesIn(precisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(inputShapes), - ::testing::ValuesIn(emptyOutputShape), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - ConvolutionBackpropDataLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/ctc_loss.cpp b/src/tests/functional/inference_engine/serialization/single_layer/ctc_loss.cpp deleted file mode 100644 index 2e5e3e5ff50..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/ctc_loss.cpp +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/ctc_loss.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(CTCLossLayerTest, Serialize) { Serialize(); } - -const std::vector fPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16}; -const std::vector iPrecisions = { - InferenceEngine::Precision::I32, - InferenceEngine::Precision::I64}; - -const std::vector preprocessCollapseRepeated = {true, false}; -const std::vector ctcMergeRepeated = {true, false}; -const std::vector unique = {true, false}; - -const auto ctcLossArgsSubset1 = ::testing::Combine( - ::testing::Values(std::vector({2, 3, 3})), // logits shape - ::testing::ValuesIn(std::vector>({{2, 3}, {3, 3}})), // logits length - ::testing::ValuesIn(std::vector>>( - {{{0, 1, 0}, {1, 0, 1}}, {{0, 1, 2}, {1, 1, 1}}})), // labels - ::testing::ValuesIn(std::vector>({{2, 2}, {2, 1}})), // labels length - ::testing::Values(2), // blank index - ::testing::ValuesIn(preprocessCollapseRepeated), - ::testing::ValuesIn(ctcMergeRepeated), - ::testing::ValuesIn(unique)); - -INSTANTIATE_TEST_SUITE_P(smoke_CTCLossSerialization, CTCLossLayerTest, - ::testing::Combine( - ctcLossArgsSubset1, - ::testing::ValuesIn(fPrecisions), - ::testing::ValuesIn(iPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - CTCLossLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/deformable_convolution.cpp b/src/tests/functional/inference_engine/serialization/single_layer/deformable_convolution.cpp deleted file mode 100644 index b90d9b6f9d3..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/deformable_convolution.cpp +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/deformable_convolution.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(DeformableConvolutionLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, InferenceEngine::Precision::I16}; -const std::vector> offsets = {{1, 18, 26, 26}}; -const std::vector> filters = {{1, 1, 3, 3}}; -const std::vector> strides = {{1, 1}}; -const std::vector> padBegins = {{0, 0}}; -const std::vector> padEnds ={{0, 0}}; -const std::vector> dilations = {{1, 1}}; -const std::vector groups = {1}; -const std::vector defor_groups = {1}; -const std::vector numOutChannels = {1}; -const std::vector with_bilinear_interpolation_pad = { false, true }; -const std::vector with_modulated_scalar = { false, true }; - -const auto conv2DParams_ExplicitPadding = ::testing::Combine( - ::testing::ValuesIn(offsets), ::testing::ValuesIn(filters), - ::testing::ValuesIn(strides), ::testing::ValuesIn(padBegins), - ::testing::ValuesIn(padEnds), ::testing::ValuesIn(dilations), - ::testing::ValuesIn(groups), ::testing::ValuesIn(defor_groups), - ::testing::ValuesIn(numOutChannels), - ::testing::Values(ngraph::op::PadType::EXPLICIT), - ::testing::ValuesIn(with_bilinear_interpolation_pad), - ::testing::ValuesIn(with_modulated_scalar)); -const auto conv2DParams_AutoPadValid = ::testing::Combine( - ::testing::ValuesIn(offsets), ::testing::ValuesIn(filters), - ::testing::ValuesIn(strides), - ::testing::Values(std::vector({0, 0})), - ::testing::Values(std::vector({0, 0})), - ::testing::ValuesIn(dilations), ::testing::ValuesIn(groups), - ::testing::ValuesIn(defor_groups), ::testing::ValuesIn(numOutChannels), - ::testing::Values(ngraph::op::PadType::VALID), - ::testing::ValuesIn(with_bilinear_interpolation_pad), - ::testing::ValuesIn(with_modulated_scalar)); - -INSTANTIATE_TEST_SUITE_P( - smoke_DeformableConvolution2D_Serialization_ExplicitPadding, DeformableConvolutionLayerTest, - ::testing::Combine( - conv2DParams_ExplicitPadding, ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({1, 1, 28, 28})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - DeformableConvolutionLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P( - smoke_DeformableConvolution2D__Serialization_AutoPadValid, DeformableConvolutionLayerTest, - ::testing::Combine( - conv2DParams_AutoPadValid, ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({1, 1, 28, 28})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - DeformableConvolutionLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/deformable_psroi_pooling.cpp b/src/tests/functional/inference_engine/serialization/single_layer/deformable_psroi_pooling.cpp deleted file mode 100644 index d0dd0b834b9..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/deformable_psroi_pooling.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/deformable_psroi_pooling.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(DeformablePSROIPoolingLayerTest, Serialize) { - Serialize(); - } - - const auto deformablePSROIParams = ::testing::Combine( - ::testing::ValuesIn(std::vector>{{3, 8, 16, 16}, {1, 8, 67, 32}}), // data input shape - ::testing::Values(std::vector{10, 5}), // rois input shape - // Empty offsets shape means test without optional third input - ::testing::ValuesIn(std::vector>{{}, {10, 2, 2, 2}}), // offsets input shape - ::testing::Values(2), // output_dim - ::testing::Values(2), // group_size - ::testing::ValuesIn(std::vector{1.0, 0.5, 0.0625}), // spatial scale - ::testing::ValuesIn(std::vector>{{1, 1}, {2, 2}, {3, 3}, {2, 3}}), // spatial_bins_x_y - ::testing::ValuesIn(std::vector{0.0, 0.01, 0.5}), // trans_std - ::testing::Values(2)); // part_size - - const auto deformablePSROICases_test_params = ::testing::Combine( - deformablePSROIParams, - ::testing::Values(InferenceEngine::Precision::FP32), // Net precision - ::testing::Values(CommonTestUtils::DEVICE_CPU)); // Device name - - INSTANTIATE_TEST_SUITE_P(smoke_TestsDeformablePSROIPooling, DeformablePSROIPoolingLayerTest, deformablePSROICases_test_params, - DeformablePSROIPoolingLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/depth_to_space.cpp b/src/tests/functional/inference_engine/serialization/single_layer/depth_to_space.cpp deleted file mode 100644 index 5284f0c900f..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/depth_to_space.cpp +++ /dev/null @@ -1,40 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/depth_to_space.hpp" - -#include - -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; -using namespace ngraph::opset3; - -namespace { -TEST_P(DepthToSpaceLayerTest, Serialize) { - Serialize(); -} -const std::vector inputPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::U8, - InferenceEngine::Precision::I16, -}; - -const std::vector modes = { - DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, - DepthToSpace::DepthToSpaceMode::DEPTH_FIRST}; - -const std::vector> inputShapesBS2 = { - {1, 4, 1, 1}, {1, 4, 2, 2}, {1, 4, 3, 3}, {2, 32, 3, 3}, - {2, 16, 5, 4}, {1, 8, 1, 1, 1}, {1, 8, 2, 2, 2}, {1, 8, 3, 3, 3}, - {2, 32, 3, 3, 3}, {2, 16, 5, 4, 6}}; - -INSTANTIATE_TEST_SUITE_P( - smoke_DepthToSpaceSerialization, DepthToSpaceLayerTest, - ::testing::Combine(::testing::ValuesIn(inputShapesBS2), - ::testing::ValuesIn(inputPrecisions), - ::testing::ValuesIn(modes), ::testing::Values(1, 2), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - DepthToSpaceLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/detection_output.cpp b/src/tests/functional/inference_engine/serialization/single_layer/detection_output.cpp deleted file mode 100644 index e5f3553765d..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/detection_output.cpp +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/detection_output.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(DetectionOutputLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16 - }; - - /* =============== Detection Output =============== */ - - const int numClasses = 11; - const int backgroundLabelId = 0; - const std::vector topK = {75}; - const std::vector> keepTopK = { {50}, {100} }; - const std::vector codeType = {"caffe.PriorBoxParameter.CORNER", "caffe.PriorBoxParameter.CENTER_SIZE"}; - const float nmsThreshold = 0.5f; - const float confidenceThreshold = 0.3f; - const std::vector clipAfterNms = {true, false}; - const std::vector clipBeforeNms = {true, false}; - const std::vector decreaseLabelId = {true, false}; - const std::vector numberBatch = {1, 2}; - const float objectnessScore = 0.4f; - - const auto commonAttributes = ::testing::Combine( - ::testing::Values(numClasses), - ::testing::Values(backgroundLabelId), - ::testing::ValuesIn(topK), - ::testing::ValuesIn(keepTopK), - ::testing::ValuesIn(codeType), - ::testing::Values(nmsThreshold), - ::testing::Values(confidenceThreshold), - ::testing::ValuesIn(clipAfterNms), - ::testing::ValuesIn(clipBeforeNms), - ::testing::ValuesIn(decreaseLabelId)); - - /* =============== 3 inputs cases =============== */ - - const std::vector specificParams3In = { - ParamsWhichSizeDepends{true, true, true, 1, 1, {1, 60}, {1, 165}, {1, 1, 60}, {}, {}}, - ParamsWhichSizeDepends{true, false, true, 1, 1, {1, 660}, {1, 165}, {1, 1, 60}, {}, {}}, - ParamsWhichSizeDepends{false, true, true, 1, 1, {1, 60}, {1, 165}, {1, 2, 60}, {}, {}}, - ParamsWhichSizeDepends{false, false, true, 1, 1, {1, 660}, {1, 165}, {1, 2, 60}, {}, {}}, - - ParamsWhichSizeDepends{true, true, false, 10, 10, {1, 60}, {1, 165}, {1, 1, 75}, {}, {}}, - ParamsWhichSizeDepends{true, false, false, 10, 10, {1, 660}, {1, 165}, {1, 1, 75}, {}, {}}, - ParamsWhichSizeDepends{false, true, false, 10, 10, {1, 60}, {1, 165}, {1, 2, 75}, {}, {}}, - ParamsWhichSizeDepends{false, false, false, 10, 10, {1, 660}, {1, 165}, {1, 2, 75}, {}, {}}}; - - const auto params3Inputs = ::testing::Combine( - commonAttributes, - ::testing::ValuesIn(specificParams3In), - ::testing::ValuesIn(numberBatch), - ::testing::Values(objectnessScore), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P( - smoke_DetectionOutput3In, - DetectionOutputLayerTest, - params3Inputs, - DetectionOutputLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/elementwise.cpp b/src/tests/functional/inference_engine/serialization/single_layer/elementwise.cpp deleted file mode 100644 index 6cca9d7e0e0..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/elementwise.cpp +++ /dev/null @@ -1,85 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/eltwise.hpp" - -using namespace ov::test::subgraph; - -namespace { -TEST_P(EltwiseLayerTest, Serialize) { - serialize(); -} - -const std::vector inputPrecisions = { - ov::element::f32, - ov::element::f16, - ov::element::i32, - }; - -std::vector> inputShapes = { - {{2}}, - {{1, 5, 50}}, - {{2, 10, 1, 4}, {2, 10, 1, 1}} -}; - -std::vector> inShapesDynamic = { - {{{ngraph::Dimension(1, 10), 200}, {{6, 200}, {1, 200}}}, - {{ngraph::Dimension(1, 10), 200}, {{2, 200}, {5, 200}}}}, -}; - -std::vector secondaryInputTypes = { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER, -}; - -std::vector opTypes = { - CommonTestUtils::OpType::SCALAR, - CommonTestUtils::OpType::VECTOR, -}; - -std::vector eltwiseOpTypes = { - ngraph::helpers::EltwiseTypes::ADD, - ngraph::helpers::EltwiseTypes::MULTIPLY, - ngraph::helpers::EltwiseTypes::SUBTRACT, - ngraph::helpers::EltwiseTypes::DIVIDE, - ngraph::helpers::EltwiseTypes::FLOOR_MOD, - ngraph::helpers::EltwiseTypes::SQUARED_DIFF, - ngraph::helpers::EltwiseTypes::POWER, - ngraph::helpers::EltwiseTypes::MOD -}; - -ov::AnyMap additionalConfig = {}; - -const auto elementiwiseParams = ::testing::Combine( - ::testing::ValuesIn(ov::test::static_shapes_to_test_representation(inputShapes)), - ::testing::ValuesIn(eltwiseOpTypes), - ::testing::ValuesIn(secondaryInputTypes), - ::testing::ValuesIn(opTypes), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(ov::element::undefined), - ::testing::Values(ov::element::undefined), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additionalConfig)); - -const auto elementiwiseParamsDyn = ::testing::Combine( - ::testing::ValuesIn(inShapesDynamic), - ::testing::ValuesIn(eltwiseOpTypes), - ::testing::ValuesIn(secondaryInputTypes), - ::testing::ValuesIn(opTypes), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(ov::element::undefined), - ::testing::Values(ov::element::undefined), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additionalConfig)); - -INSTANTIATE_TEST_SUITE_P(smoke_ElementwiseSerialization_static, EltwiseLayerTest, - elementiwiseParams, - EltwiseLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_ElementwiseSerialization_dynamic, EltwiseLayerTest, - elementiwiseParamsDyn, - EltwiseLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/embedding_bag_offsets_sum.cpp b/src/tests/functional/inference_engine/serialization/single_layer/embedding_bag_offsets_sum.cpp deleted file mode 100644 index 95d6edfaa56..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/embedding_bag_offsets_sum.cpp +++ /dev/null @@ -1,48 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/embedding_bag_offsets_sum.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(EmbeddingBagOffsetsSumLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U8}; - - const std::vector indPrecisions = { - InferenceEngine::Precision::I64, - InferenceEngine::Precision::I32}; - - const std::vector> emb_table_shape = {{5, 6}, {5, 4, 16}}; - const std::vector> indices = - {{0, 1, 2, 2, 3}, {4, 4, 3, 1, 0}, {1, 2, 1, 2, 1, 2, 1, 2, 1, 2}}; - const std::vector> offsets = {{0, 2}, {0, 0, 2, 2}, {2, 4}}; - const std::vector default_index = {0, 4}; - const std::vector with_weights = {false, true}; - const std::vector with_default_index = {false, true}; - - const auto EmbeddingBagOffsetsSumParams = ::testing::Combine( - ::testing::ValuesIn(emb_table_shape), - ::testing::ValuesIn(indices), - ::testing::ValuesIn(offsets), - ::testing::ValuesIn(default_index), - ::testing::ValuesIn(with_weights), - ::testing::ValuesIn(with_default_index)); - - INSTANTIATE_TEST_SUITE_P( - smoke_EmbeddingBagOffsetsSumLayerTest_Serialization, EmbeddingBagOffsetsSumLayerTest, - ::testing::Combine(EmbeddingBagOffsetsSumParams, - ::testing::ValuesIn(netPrecisions), - ::testing::ValuesIn(indPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - EmbeddingBagOffsetsSumLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/embedding_bag_packed_sum.cpp b/src/tests/functional/inference_engine/serialization/single_layer/embedding_bag_packed_sum.cpp deleted file mode 100644 index 96d15c30340..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/embedding_bag_packed_sum.cpp +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/embedding_bag_packed_sum.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(EmbeddingBagPackedSumLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U8}; - - const std::vector indPrecisions = { - InferenceEngine::Precision::I64, - InferenceEngine::Precision::I32}; - - const std::vector> emb_table_shape = {{5, 6}, {10, 35}, {5, 4, 16}}; - const std::vector>> indices = - {{{0, 1}, {2, 2}}, {{4, 4, 3}, {1, 0, 2}}, {{1, 2, 1, 2}}}; - const std::vector with_weights = {false, true}; - - const auto EmbeddingBagPackedSumParams = ::testing::Combine( - ::testing::ValuesIn(emb_table_shape), - ::testing::ValuesIn(indices), - ::testing::ValuesIn(with_weights)); - - INSTANTIATE_TEST_SUITE_P( - smoke_EmbeddingBagPackedSumLayerTest_Serialization, EmbeddingBagPackedSumLayerTest, - ::testing::Combine(EmbeddingBagPackedSumParams, - ::testing::ValuesIn(netPrecisions), - ::testing::ValuesIn(indPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - EmbeddingBagPackedSumLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/embedding_segments_sum.cpp b/src/tests/functional/inference_engine/serialization/single_layer/embedding_segments_sum.cpp deleted file mode 100644 index 3e561a82085..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/embedding_segments_sum.cpp +++ /dev/null @@ -1,50 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/embedding_segments_sum.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(EmbeddingSegmentsSumLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U8}; - - const std::vector indPrecisions = { - InferenceEngine::Precision::I64, - InferenceEngine::Precision::I32}; - - const std::vector> emb_table_shape = {{5, 6}, {5, 4, 16}}; - const std::vector> indices = - {{0, 1, 2, 2, 3}, {4, 4, 3, 1, 2}}; - const std::vector> segment_ids = {{0, 1, 2, 3, 4}, {0, 0, 2, 2, 4}}; - const std::vector num_segments = {5, 7}; - const std::vector default_index = {0, 4}; - const std::vector with_weights = {false, true}; - const std::vector with_default_index = {false, true}; - - const auto EmbeddingSegmentsSumParams = ::testing::Combine( - ::testing::ValuesIn(emb_table_shape), - ::testing::ValuesIn(indices), - ::testing::ValuesIn(segment_ids), - ::testing::ValuesIn(num_segments), - ::testing::ValuesIn(default_index), - ::testing::ValuesIn(with_weights), - ::testing::ValuesIn(with_default_index)); - - INSTANTIATE_TEST_SUITE_P( - smoke_EmbeddingSegmentsSumLayerTest_Serialization, EmbeddingSegmentsSumLayerTest, - ::testing::Combine(EmbeddingSegmentsSumParams, - ::testing::ValuesIn(netPrecisions), - ::testing::ValuesIn(indPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - EmbeddingSegmentsSumLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/equal.cpp b/src/tests/functional/inference_engine/serialization/single_layer/equal.cpp deleted file mode 100644 index c4f59ba83a9..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/equal.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "comparison_ops.hpp" - -using namespace LayerTestsDefinitions; -using namespace LayerTestsDefinitions::ComparisonParams; - -namespace { -TEST_P(ComparisonLayerTest, Serialize) { - Serialize(); - } - -ComparisionOpsData data = { - // inputsShape - { - {{1}, {{1}, {17}, {1, 1}, {2, 18}, {1, 1, 2}, {2, 2, 3}, {1, 1, 2, 3}}}, - {{5}, {{1}, {1, 1}, {2, 5}, {1, 1, 1}, {2, 2, 5}}}, - {{2, 200}, {{1}, {200}, {1, 200}, {2, 200}, {2, 2, 200}}}, - {{1, 3, 20}, {{20}, {2, 1, 1}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {2, 1, 3, 4}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {141, 1, 3, 4}}}, - {{2, 1, 1, 3, 1}, {{1}, {1, 3, 4}, {2, 1, 3, 4}, {1, 1, 1, 1, 1}}}, - }, - // inputsPrecisions - { - InferenceEngine::Precision::FP64, - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U32, - InferenceEngine::Precision::BOOL, - }, - // secondIinputsType - { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER, - }, - // additionalConfig - {}, - // opType - ngraph::helpers::ComparisonTypes::EQUAL, - // ieInputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // ieOutputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // deviceName - CommonTestUtils::DEVICE_CPU, -}; - -const auto SerializeEqualTestParams = ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(data.inputShapes)), - ::testing::ValuesIn(data.inputsPrecisions), - ::testing::Values(data.opType), - ::testing::ValuesIn(data.secondInputTypes), - ::testing::Values(data.ieInputPrecision), - ::testing::Values(data.ieOutputPrecision), - ::testing::Values(data.deviceName), - ::testing::Values(data.additional_config)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, ComparisonLayerTest, SerializeEqualTestParams, ComparisonLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/extractimagepatches.cpp b/src/tests/functional/inference_engine/serialization/single_layer/extractimagepatches.cpp deleted file mode 100644 index 04e7c532a34..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/extractimagepatches.cpp +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include "shared_test_classes/single_layer/extract_image_patches.hpp" - -using namespace ngraph; -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(ExtractImagePatchesTest, Serialize) { - Serialize(); -} - -const std::vector> inShapes = {{2, 3, 13, 37}}; -const std::vector> kSizes = {{1, 5}, {3, 4}, {3, 1}}; -const std::vector> strides = {{1, 2}, {2, 2}, {2, 1}}; -const std::vector> rates = {{1, 3}, {3, 3}, {3, 1}}; - -const std::vector autoPads = { - ngraph::op::PadType::VALID, ngraph::op::PadType::SAME_UPPER, - ngraph::op::PadType::SAME_LOWER -}; -const std::vector netPrecision = { - InferenceEngine::Precision::I8, InferenceEngine::Precision::BF16, - InferenceEngine::Precision::FP32 -}; - -INSTANTIATE_TEST_SUITE_P(smoke_ExtractImagePatchesLayerTest, ExtractImagePatchesTest, - ::testing::Combine(::testing::ValuesIn(inShapes), - ::testing::ValuesIn(kSizes), - ::testing::ValuesIn(strides), - ::testing::ValuesIn(rates), - ::testing::ValuesIn(autoPads), - ::testing::ValuesIn(netPrecision), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - ExtractImagePatchesTest::getTestCaseName); - -} // namespace \ No newline at end of file diff --git a/src/tests/functional/inference_engine/serialization/single_layer/gather_tree.cpp b/src/tests/functional/inference_engine/serialization/single_layer/gather_tree.cpp deleted file mode 100644 index 1f9984f9f2f..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/gather_tree.cpp +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/gather_tree.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(GatherTreeLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::I32 -}; - -const std::vector> inputShapes = { {5, 1, 10}, {1, 1, 10}, {20, 1, 10}, {20, 20, 10} }; - -const std::vector secondaryInputTypes = { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER -}; - -INSTANTIATE_TEST_SUITE_P(smoke_GatherTree_Serialization, GatherTreeLayerTest, - ::testing::Combine( - ::testing::ValuesIn(inputShapes), - ::testing::ValuesIn(secondaryInputTypes), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - GatherTreeLayerTest::getTestCaseName); -} // namespace \ No newline at end of file diff --git a/src/tests/functional/inference_engine/serialization/single_layer/greater.cpp b/src/tests/functional/inference_engine/serialization/single_layer/greater.cpp deleted file mode 100644 index 7925387fbb7..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/greater.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "comparison_ops.hpp" - -using namespace LayerTestsDefinitions; -using namespace LayerTestsDefinitions::ComparisonParams; - -namespace { -TEST_P(ComparisonLayerTest, Serialize) { - Serialize(); - } - -ComparisionOpsData data = { - // inputsShape - { - {{1}, {{1}, {17}, {1, 1}, {2, 18}, {1, 1, 2}, {2, 2, 3}, {1, 1, 2, 3}}}, - {{5}, {{1}, {1, 1}, {2, 5}, {1, 1, 1}, {2, 2, 5}}}, - {{2, 200}, {{1}, {200}, {1, 200}, {2, 200}, {2, 2, 200}}}, - {{1, 3, 20}, {{20}, {2, 1, 1}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {2, 1, 3, 4}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {141, 1, 3, 4}}}, - {{2, 1, 1, 3, 1}, {{1}, {1, 3, 4}, {2, 1, 3, 4}, {1, 1, 1, 1, 1}}}, - }, - // inputsPrecisions - { - InferenceEngine::Precision::FP64, - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U32, - InferenceEngine::Precision::BOOL, - }, - // secondIinputsType - { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER, - }, - // additionalConfig - {}, - // opType - ngraph::helpers::ComparisonTypes::GREATER, - // ieInputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // ieOutputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // deviceName - CommonTestUtils::DEVICE_CPU, -}; - -const auto SerializeGreaterTestParams = ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(data.inputShapes)), - ::testing::ValuesIn(data.inputsPrecisions), - ::testing::Values(data.opType), - ::testing::ValuesIn(data.secondInputTypes), - ::testing::Values(data.ieInputPrecision), - ::testing::Values(data.ieOutputPrecision), - ::testing::Values(data.deviceName), - ::testing::Values(data.additional_config)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, ComparisonLayerTest, SerializeGreaterTestParams, ComparisonLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/greater_eq.cpp b/src/tests/functional/inference_engine/serialization/single_layer/greater_eq.cpp deleted file mode 100644 index c2cd090e7f3..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/greater_eq.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "comparison_ops.hpp" - -using namespace LayerTestsDefinitions; -using namespace LayerTestsDefinitions::ComparisonParams; - -namespace { -TEST_P(ComparisonLayerTest, Serialize) { - Serialize(); - } - -ComparisionOpsData data = { - // inputsShape - { - {{1}, {{1}, {17}, {1, 1}, {2, 18}, {1, 1, 2}, {2, 2, 3}, {1, 1, 2, 3}}}, - {{5}, {{1}, {1, 1}, {2, 5}, {1, 1, 1}, {2, 2, 5}}}, - {{2, 200}, {{1}, {200}, {1, 200}, {2, 200}, {2, 2, 200}}}, - {{1, 3, 20}, {{20}, {2, 1, 1}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {2, 1, 3, 4}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {141, 1, 3, 4}}}, - {{2, 1, 1, 3, 1}, {{1}, {1, 3, 4}, {2, 1, 3, 4}, {1, 1, 1, 1, 1}}}, - }, - // inputsPrecisions - { - InferenceEngine::Precision::FP64, - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U32, - InferenceEngine::Precision::BOOL, - }, - // secondIinputsType - { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER, - }, - // additionalConfig - {}, - // opType - ngraph::helpers::ComparisonTypes::GREATER_EQUAL, - // ieInputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // ieOutputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // deviceName - CommonTestUtils::DEVICE_CPU, -}; - -const auto SerializeGreaterEqualTestParams = ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(data.inputShapes)), - ::testing::ValuesIn(data.inputsPrecisions), - ::testing::Values(data.opType), - ::testing::ValuesIn(data.secondInputTypes), - ::testing::Values(data.ieInputPrecision), - ::testing::Values(data.ieOutputPrecision), - ::testing::Values(data.deviceName), - ::testing::Values(data.additional_config)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, ComparisonLayerTest, SerializeGreaterEqualTestParams, ComparisonLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/grn.cpp b/src/tests/functional/inference_engine/serialization/single_layer/grn.cpp deleted file mode 100644 index 486a7ec11a6..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/grn.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright (C) 2020-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/grn.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(GrnLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32 -}; - -const auto basicCases = ::testing::Combine( - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - // input shapes - ::testing::Values(std::vector{2, 16, 15, 20}), - // bias - ::testing::Values(1e-6f), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P(smoke_GRN_Serialization, GrnLayerTest, - basicCases, - GrnLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/group_convolution.cpp b/src/tests/functional/inference_engine/serialization/single_layer/group_convolution.cpp deleted file mode 100644 index 78f7b6da968..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/group_convolution.cpp +++ /dev/null @@ -1,55 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/group_convolution.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(GroupConvolutionLayerTest, Serialize) { - Serialize(); -} - -const std::vector precisions = { - InferenceEngine::Precision::FP64, InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, InferenceEngine::Precision::BF16, - InferenceEngine::Precision::I8, InferenceEngine::Precision::I16, - InferenceEngine::Precision::I32, InferenceEngine::Precision::I64, - InferenceEngine::Precision::U8, InferenceEngine::Precision::U16, - InferenceEngine::Precision::U32, InferenceEngine::Precision::U64, -}; -const std::vector> kernels = {{3, 3}}; -const std::vector> strides = {{1, 1}}; -const std::vector> padBegins = {{0, 0}}; -const std::vector> padEnds = {{0, 0}}; -const std::vector> dilations = {{1, 1}}; -const std::vector numOutChannels = {8, 16}; -const std::vector numGroups = {2, 8}; -const std::vector pad_types = { - ngraph::op::PadType::EXPLICIT, ngraph::op::PadType::VALID, - ngraph::op::PadType::SAME_LOWER, ngraph::op::PadType::SAME_UPPER}; -const auto inputShapes = std::vector({1, 16, 30, 30}); - -const auto groupConv2DParams = ::testing::Combine( - ::testing::ValuesIn(kernels), ::testing::ValuesIn(strides), - ::testing::ValuesIn(padBegins), ::testing::ValuesIn(padEnds), - ::testing::ValuesIn(dilations), ::testing::ValuesIn(numOutChannels), - ::testing::ValuesIn(numGroups), ::testing::ValuesIn(pad_types)); - -INSTANTIATE_TEST_SUITE_P( - smoke_GroupConvolution2D_Serialization, GroupConvolutionLayerTest, - ::testing::Combine( - groupConv2DParams, ::testing::ValuesIn(precisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(inputShapes), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - GroupConvolutionLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/group_convolution_backprop_data.cpp b/src/tests/functional/inference_engine/serialization/single_layer/group_convolution_backprop_data.cpp deleted file mode 100644 index ce73340ac3c..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/group_convolution_backprop_data.cpp +++ /dev/null @@ -1,60 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/group_convolution_backprop_data.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(GroupConvBackpropLayerTest, Serialize) { - Serialize(); -} - -const std::vector precisions = { - InferenceEngine::Precision::FP64, InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, InferenceEngine::Precision::BF16, - InferenceEngine::Precision::I8, InferenceEngine::Precision::I16, - InferenceEngine::Precision::I32, InferenceEngine::Precision::I64, - InferenceEngine::Precision::U8, InferenceEngine::Precision::U16, - InferenceEngine::Precision::U32, InferenceEngine::Precision::U64, -}; -const std::vector> kernels = {{3, 3}}; -const std::vector> strides = {{1, 1}}; -const std::vector> padBegins = {{0, 0}}; -const std::vector> padEnds = {{0, 0}}; -const std::vector> outputPadding = {{}, {1, 1}}; -const std::vector> dilations = {{1, 1}}; -const std::vector numOutChannels = {8, 16}; -const std::vector numGroups = {2, 8}; -const std::vector pad_types = { - ngraph::op::PadType::EXPLICIT, ngraph::op::PadType::VALID, - ngraph::op::PadType::SAME_LOWER, ngraph::op::PadType::SAME_UPPER}; -const auto inputShapes = std::vector({1, 16, 30, 30}); -const std::vector> emptyOutputShape = {{}}; - -const auto groupConvBackpropData2DParams = ::testing::Combine( - ::testing::ValuesIn(kernels), ::testing::ValuesIn(strides), - ::testing::ValuesIn(padBegins), ::testing::ValuesIn(padEnds), - ::testing::ValuesIn(dilations), ::testing::ValuesIn(numOutChannels), - ::testing::ValuesIn(numGroups), ::testing::ValuesIn(pad_types), - ::testing::ValuesIn(outputPadding)); - -INSTANTIATE_TEST_SUITE_P( - smoke_GroupConvBackpropData2D_Serialization, GroupConvBackpropLayerTest, - ::testing::Combine( - groupConvBackpropData2DParams, - ::testing::ValuesIn(precisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(inputShapes), - ::testing::ValuesIn(emptyOutputShape), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - GroupConvBackpropLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/less.cpp b/src/tests/functional/inference_engine/serialization/single_layer/less.cpp deleted file mode 100644 index a3867091060..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/less.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "comparison_ops.hpp" - -using namespace LayerTestsDefinitions; -using namespace LayerTestsDefinitions::ComparisonParams; - -namespace { -TEST_P(ComparisonLayerTest, Serialize) { - Serialize(); - } - -ComparisionOpsData data = { - // inputsShape - { - {{1}, {{1}, {17}, {1, 1}, {2, 18}, {1, 1, 2}, {2, 2, 3}, {1, 1, 2, 3}}}, - {{5}, {{1}, {1, 1}, {2, 5}, {1, 1, 1}, {2, 2, 5}}}, - {{2, 200}, {{1}, {200}, {1, 200}, {2, 200}, {2, 2, 200}}}, - {{1, 3, 20}, {{20}, {2, 1, 1}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {2, 1, 3, 4}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {141, 1, 3, 4}}}, - {{2, 1, 1, 3, 1}, {{1}, {1, 3, 4}, {2, 1, 3, 4}, {1, 1, 1, 1, 1}}}, - }, - // inputsPrecisions - { - InferenceEngine::Precision::FP64, - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U32, - InferenceEngine::Precision::BOOL, - }, - // secondIinputsType - { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER, - }, - // additionalConfig - {}, - // opType - ngraph::helpers::ComparisonTypes::LESS, - // ieInputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // ieOutputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // deviceName - CommonTestUtils::DEVICE_CPU, -}; - -const auto SerializeLessTestParams = ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(data.inputShapes)), - ::testing::ValuesIn(data.inputsPrecisions), - ::testing::Values(data.opType), - ::testing::ValuesIn(data.secondInputTypes), - ::testing::Values(data.ieInputPrecision), - ::testing::Values(data.ieOutputPrecision), - ::testing::Values(data.deviceName), - ::testing::Values(data.additional_config)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, ComparisonLayerTest, SerializeLessTestParams, ComparisonLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/less_eq.cpp b/src/tests/functional/inference_engine/serialization/single_layer/less_eq.cpp deleted file mode 100644 index 8e41fa39f56..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/less_eq.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "comparison_ops.hpp" - -using namespace LayerTestsDefinitions; -using namespace LayerTestsDefinitions::ComparisonParams; - -namespace { -TEST_P(ComparisonLayerTest, Serialize) { - Serialize(); - } - -ComparisionOpsData data = { - // inputsShape - { - {{1}, {{1}, {17}, {1, 1}, {2, 18}, {1, 1, 2}, {2, 2, 3}, {1, 1, 2, 3}}}, - {{5}, {{1}, {1, 1}, {2, 5}, {1, 1, 1}, {2, 2, 5}}}, - {{2, 200}, {{1}, {200}, {1, 200}, {2, 200}, {2, 2, 200}}}, - {{1, 3, 20}, {{20}, {2, 1, 1}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {2, 1, 3, 4}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {141, 1, 3, 4}}}, - {{2, 1, 1, 3, 1}, {{1}, {1, 3, 4}, {2, 1, 3, 4}, {1, 1, 1, 1, 1}}}, - }, - // inputsPrecisions - { - InferenceEngine::Precision::FP64, - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U32, - InferenceEngine::Precision::BOOL, - }, - // secondIinputsType - { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER, - }, - // additionalConfig - {}, - // opType - ngraph::helpers::ComparisonTypes::LESS_EQUAL, - // ieInputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // ieOutputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // deviceName - CommonTestUtils::DEVICE_CPU, -}; - -const auto SerializeLessEqualTestParams = ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(data.inputShapes)), - ::testing::ValuesIn(data.inputsPrecisions), - ::testing::Values(data.opType), - ::testing::ValuesIn(data.secondInputTypes), - ::testing::Values(data.ieInputPrecision), - ::testing::Values(data.ieOutputPrecision), - ::testing::Values(data.deviceName), - ::testing::Values(data.additional_config)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, ComparisonLayerTest, SerializeLessEqualTestParams, ComparisonLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/logical.cpp b/src/tests/functional/inference_engine/serialization/single_layer/logical.cpp deleted file mode 100644 index fcc2c7577a8..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/logical.cpp +++ /dev/null @@ -1,84 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include "shared_test_classes/single_layer/logical.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; -using namespace LayerTestsDefinitions::LogicalParams; - -namespace { -TEST_P(LogicalLayerTest, Serialize) { - Serialize(); -} - -std::map, std::vector>> inputShapes = { - {{1}, {{1}, {17}, {1, 1}, {2, 18}, {1, 1, 2}, {2, 2, 3}, {1, 1, 2, 3}}}, - {{5}, {{1}, {1, 1}, {2, 5}, {1, 1, 1}, {2, 2, 5}}}, - {{2, 200}, {{1}, {200}, {1, 200}, {2, 200}, {2, 2, 200}}}, - {{1, 3, 20}, {{20}, {2, 1, 1}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {2, 1, 3, 4}}}, - {{2, 1, 1, 3, 1}, {{1}, {1, 3, 4}, {2, 1, 3, 4}, {1, 1, 1, 1, 1}}}, -}; - -std::map, std::vector>> inputShapesNot = { - {{1}, {}}, - {{5}, {}}, - {{2, 200}, {}}, - {{1, 3, 20}, {}}, - {{2, 17, 3, 4}, {}}, - {{2, 1, 1, 3, 1}, {}}, -}; - -std::vector inputsPrecisions = { - InferenceEngine::Precision::BOOL, -}; - -std::vector logicalOpTypes = { - ngraph::helpers::LogicalTypes::LOGICAL_AND, - ngraph::helpers::LogicalTypes::LOGICAL_OR, - ngraph::helpers::LogicalTypes::LOGICAL_XOR, -}; - -std::vector secondInputTypes = { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER, -}; - -std::vector netPrecisions = { - InferenceEngine::Precision::FP32, -}; - -std::map additional_config = {}; - -const auto LogicalTestParams = ::testing::Combine( - ::testing::ValuesIn(LogicalLayerTest::combineShapes(inputShapes)), - ::testing::ValuesIn(logicalOpTypes), - ::testing::ValuesIn(secondInputTypes), - ::testing::ValuesIn(netPrecisions), - ::testing::ValuesIn(inputsPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additional_config)); - -const auto LogicalNotTestParams = ::testing::Combine( - ::testing::ValuesIn(LogicalLayerTest::combineShapes(inputShapesNot)), - ::testing::Values(ngraph::helpers::LogicalTypes::LOGICAL_NOT), - ::testing::Values(ngraph::helpers::InputLayerType::CONSTANT), - ::testing::ValuesIn(netPrecisions), - ::testing::ValuesIn(inputsPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(additional_config)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, LogicalLayerTest, LogicalTestParams, LogicalLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefsNot, LogicalLayerTest, LogicalNotTestParams, LogicalLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/matrix_nms.cpp b/src/tests/functional/inference_engine/serialization/single_layer/matrix_nms.cpp deleted file mode 100644 index ac8610b9b13..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/matrix_nms.cpp +++ /dev/null @@ -1,69 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/matrix_nms.hpp" - -using namespace ngraph; -using namespace ov::test::subgraph; - -namespace { - TEST_P(MatrixNmsLayerTest, Serialize) { - serialize(); - } - - const std::vector netPrecisions = { - ov::element::f32, - ov::element::f16 - }; - - const std::vector> shapeParams = { - // num_batches, num_boxes, 4 - {{{ngraph::Dimension::dynamic(), ngraph::Dimension::dynamic(), 4}, - {{1, 10, 4}, {2, 100, 4}}}, - // num_batches, num_classes, num_boxes - {{ngraph::Dimension::dynamic(), ngraph::Dimension::dynamic(), ngraph::Dimension::dynamic()}, - {{1, 3, 10}, {2, 5, 100}}}}, - // num_batches, num_boxes, 4 - {{{ngraph::Dimension(1, 10), ngraph::Dimension(1, 100), 4}, - {{1, 10, 4}, {2, 100, 4}}}, - // num_batches, num_classes, num_boxes - {{{ngraph::Dimension(1, 10), ngraph::Dimension(1, 100), ngraph::Dimension(1, 100)}}, - {{1, 3, 10}, {2, 5, 100}}}} - }; - - const std::vector sortResultType = {op::v8::MatrixNms::SortResultType::CLASSID, - op::v8::MatrixNms::SortResultType::SCORE, - op::v8::MatrixNms::SortResultType::NONE}; - const std::vector outType = {element::i32, element::i64}; - const std::vector topKParams = { - TopKParams{-1, 5}, - TopKParams{100, -1} - }; - const std::vector thresholdParams = { - ThresholdParams{0.0f, 2.0f, 0.0f}, - ThresholdParams{0.1f, 1.5f, 0.2f} - }; - const std::vector nmsTopK = {-1, 100}; - const std::vector keepTopK = {-1, 5}; - const std::vector backgroudClass = {-1, 0}; - const std::vector normalized = {true, false}; - const std::vector decayFunction = {op::v8::MatrixNms::DecayFunction::GAUSSIAN, - op::v8::MatrixNms::DecayFunction::LINEAR}; - const auto nmsParams = ::testing::Combine(::testing::ValuesIn(shapeParams), - ::testing::Combine(::testing::Values(ov::element::f32), - ::testing::Values(ov::element::i32), - ::testing::Values(ov::element::f32)), - ::testing::ValuesIn(sortResultType), - ::testing::ValuesIn(outType), - ::testing::ValuesIn(topKParams), - ::testing::ValuesIn(thresholdParams), - ::testing::ValuesIn(backgroudClass), - ::testing::ValuesIn(normalized), - ::testing::ValuesIn(decayFunction), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - - INSTANTIATE_TEST_SUITE_P(smoke_MatrixNmsLayerTest, MatrixNmsLayerTest, nmsParams, MatrixNmsLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/minimum_maximum.cpp b/src/tests/functional/inference_engine/serialization/single_layer/minimum_maximum.cpp deleted file mode 100644 index de18dc012cd..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/minimum_maximum.cpp +++ /dev/null @@ -1,52 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include "shared_test_classes/single_layer/minimum_maximum.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(MaxMinLayerTest, Serialize) { Serialize(); } - -const std::vector>> inShapes = { - {{2}, {1}}, - {{1, 1, 1, 3}, {1}}, - {{1, 2, 4}, {1}}, - {{1, 4, 4}, {1}}, - {{1, 4, 4, 1}, {1}}, - {{256, 56}, {256, 56}}, - {{8, 1, 6, 1}, {7, 1, 5}}, -}; - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, -}; - -const std::vector opType = { - ngraph::helpers::MinMaxOpType::MINIMUM, - ngraph::helpers::MinMaxOpType::MAXIMUM, -}; - -const std::vector inputType = { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER, -}; - -INSTANTIATE_TEST_SUITE_P(smoke_maximum, MaxMinLayerTest, - ::testing::Combine( - ::testing::ValuesIn(inShapes), - ::testing::ValuesIn(opType), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::ValuesIn(inputType), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - MaxMinLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/multiclass_nms.cpp b/src/tests/functional/inference_engine/serialization/single_layer/multiclass_nms.cpp deleted file mode 100644 index 32caae615f9..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/multiclass_nms.cpp +++ /dev/null @@ -1,120 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/multiclass_nms.hpp" - -using namespace ngraph; -using namespace ov::test::subgraph; - -namespace { -TEST_P(MulticlassNmsLayerTest, Serialize) { - serialize(); -} - -/* input format #1 with 2 inputs: bboxes N, M, 4, scores N, C, M */ -const std::vector> shapeParams1 = { - // num_batches, num_boxes, 4 - {{{ngraph::Dimension::dynamic(), ngraph::Dimension::dynamic(), 4}, - {{1, 10, 4}, {2, 100, 4}}}, - // num_batches, num_classes, num_boxes - {{ngraph::Dimension::dynamic(), ngraph::Dimension::dynamic(), ngraph::Dimension::dynamic()}, - {{1, 3, 10}, {2, 5, 100}}}}, - {{{ngraph::Dimension(1, 10), ngraph::Dimension(1, 100), 4}, - {{1, 10, 4}, {2, 100, 4}}}, - {{{ngraph::Dimension(1, 10), ngraph::Dimension(1, 100), ngraph::Dimension(1, 100)}}, - {{1, 3, 10}, {2, 5, 100}}}} -}; - -/* input format #2 with 3 inputs: bboxes C, M, 4, scores C, M, roisnum N */ -const std::vector> shapeParams2 = { - /*0*/ - // bboxes - {{{ngraph::Dimension::dynamic(), ngraph::Dimension::dynamic(), 4}, - {{1, 10, 4}, {2, 100, 4}}}, - // scores - {{ngraph::Dimension::dynamic(), ngraph::Dimension::dynamic()}, - {{1, 10}, {2, 100}}}, - // roisnum - {{ngraph::Dimension::dynamic()}, - {{1}, {10}}}}, - /*1*/ - {{{ngraph::Dimension(1, 10), ngraph::Dimension(1, 100), 4}, - {{1, 10, 4}, {2, 100, 4}}}, - {{{ngraph::Dimension(1, 10), ngraph::Dimension(1, 100)}}, - {{1, 10}, {2, 100}}}, - {{ngraph::Dimension::dynamic()}, - {{1}, {10}}}}, - /*2*/ - {{{ngraph::Dimension(3), ngraph::Dimension(2), 4}, - {{3, 2, 4}}}, - {{{ngraph::Dimension(3), ngraph::Dimension(2)}}, - {{3, 2}}}, - {{ngraph::Dimension::dynamic()}, - {{1}, {2}}}} -}; - -const std::vector nmsTopK = {-1, 20}; -const std::vector iouThreshold = {0.7f}; -const std::vector scoreThreshold = {0.7f}; -const std::vector backgroundClass = {-1, 0}; -const std::vector keepTopK = {-1, 30}; -const std::vector outType = {element::i32, element::i64}; - -const std::vector sortResultType = { - op::v8::MulticlassNms::SortResultType::SCORE, - op::v8::MulticlassNms::SortResultType::CLASSID, - op::v8::MulticlassNms::SortResultType::NONE}; -const std::vector sortResDesc = {true, false}; -const std::vector nmsEta = {0.6f, 1.0f}; -const std::vector normalized = {true, false}; - -const auto nmsParams1_smoke = ::testing::Combine( - ::testing::ValuesIn(shapeParams1), - ::testing::Combine(::testing::Values(ov::element::f32), - ::testing::Values(ov::element::i32), - ::testing::Values(ov::element::i32), - ::testing::Values(ov::element::f32)), - ::testing::ValuesIn(nmsTopK), - ::testing::Combine(::testing::ValuesIn(iouThreshold), - ::testing::ValuesIn(scoreThreshold), - ::testing::ValuesIn(nmsEta)), - ::testing::ValuesIn(backgroundClass), - ::testing::ValuesIn(keepTopK), - ::testing::ValuesIn(outType), - ::testing::ValuesIn(sortResultType), - ::testing::Combine(::testing::ValuesIn(sortResDesc), - ::testing::ValuesIn(normalized)), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P(smoke_MulticlassNmsLayerTest1, - MulticlassNmsLayerTest, - nmsParams1_smoke, - MulticlassNmsLayerTest::getTestCaseName); - - -const auto nmsParams2_smoke = ::testing::Combine( - ::testing::ValuesIn(shapeParams2), - ::testing::Combine(::testing::Values(ov::element::f32), - ::testing::Values(ov::element::i32), - ::testing::Values(ov::element::i32), - ::testing::Values(ov::element::f32)), - ::testing::ValuesIn(nmsTopK), - ::testing::Combine(::testing::ValuesIn(iouThreshold), - ::testing::ValuesIn(scoreThreshold), - ::testing::ValuesIn(nmsEta)), - ::testing::ValuesIn(backgroundClass), - ::testing::ValuesIn(keepTopK), - ::testing::ValuesIn(outType), - ::testing::ValuesIn(sortResultType), - ::testing::Combine(::testing::ValuesIn(sortResDesc), - ::testing::ValuesIn(normalized)), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P(smoke_MulticlassNmsLayerTest2, - MulticlassNmsLayerTest, - nmsParams2_smoke, - MulticlassNmsLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/mvn.cpp b/src/tests/functional/inference_engine/serialization/single_layer/mvn.cpp deleted file mode 100644 index 619f216fc87..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/mvn.cpp +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/mvn.hpp" - -using namespace LayerTestsDefinitions; - -std::vector dataPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP16}; - -const std::vector normalizeVariance = {true, false}; - -// ------------------- MVN-1 ------------------------------------------------- -const std::vector> inputShapes = {{1, 10, 5, 7, 8}, - {1, 3, 8, 9, 49}}; - -const std::vector axes = {{1, 2, 3}, {2, 3}}; -const std::vector acrossChannels = {true, false}; -const std::vector emptyReductionAxes = {{}}; -const std::vector emptyAcrossChannels = {{}}; - -const std::vector epsilon = {0.000000001}; - -const auto MvnAcrossChannels = ::testing::Combine( - ::testing::ValuesIn(inputShapes), ::testing::ValuesIn(dataPrecisions), - ::testing::ValuesIn(emptyReductionAxes), ::testing::ValuesIn(acrossChannels), - ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -const auto MvnReductionAxes = ::testing::Combine( - ::testing::ValuesIn(inputShapes), ::testing::ValuesIn(dataPrecisions), - ::testing::ValuesIn(axes), ::testing::ValuesIn(emptyAcrossChannels), - ::testing::ValuesIn(normalizeVariance), ::testing::ValuesIn(epsilon), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -TEST_P(Mvn1LayerTest, Serialize) { - Serialize(); -} - -INSTANTIATE_TEST_SUITE_P(smoke_INTEL_CPU_TestsMVN_across_channels, Mvn1LayerTest, MvnAcrossChannels, - Mvn1LayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_INTEL_CPU_TestsMVN_reduction_axes, Mvn1LayerTest, MvnReductionAxes, - Mvn1LayerTest::getTestCaseName); - -// ------------------- MVN-6 ------------------------------------------------- - -std::vector idxPrecisions = { - InferenceEngine::Precision::I32, InferenceEngine::Precision::I64}; - -const std::vector epsMode = {"inside_sqrt", "outside_sqrt"}; - -const std::vector epsilonF = {0.0001}; - -TEST_P(Mvn6LayerTest, Serialize) { - Serialize(); -} - -INSTANTIATE_TEST_SUITE_P( - smoke_MVN_5D, Mvn6LayerTest, - ::testing::Combine(::testing::ValuesIn(std::vector>{ - {1, 10, 5, 7, 8}, {1, 3, 8, 9, 49}}), - ::testing::ValuesIn(dataPrecisions), - ::testing::ValuesIn(idxPrecisions), - ::testing::ValuesIn(std::vector>{ - {1, 2, 3, 4}, {2, 3, 4}}), - ::testing::ValuesIn(normalizeVariance), - ::testing::ValuesIn(epsilonF), - ::testing::ValuesIn(epsMode), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - Mvn6LayerTest::getTestCaseName); diff --git a/src/tests/functional/inference_engine/serialization/single_layer/non_max_suppression.cpp b/src/tests/functional/inference_engine/serialization/single_layer/non_max_suppression.cpp deleted file mode 100644 index 19bf6455d0a..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/non_max_suppression.cpp +++ /dev/null @@ -1,57 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/non_max_suppression.hpp" - -using namespace ngraph; -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(NmsLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16 - }; - - /* ============= NO MAX SUPPRESSION ============= */ - - const std::vector inShapeParams = { - InputShapeParams{3, 100, 5}, - InputShapeParams{1, 10, 50}, - InputShapeParams{2, 50, 50} - }; - - const std::vector maxOutBoxPerClass = {5, 20}; - const std::vector threshold = {0.3f, 0.7f}; - const std::vector sigmaThreshold = {0.0f, 0.5f}; - const std::vector encodType = {op::v5::NonMaxSuppression::BoxEncodingType::CENTER, - op::v5::NonMaxSuppression::BoxEncodingType::CORNER}; - const std::vector sortResDesc = {true, false}; - const std::vector outType = {element::i32, element::i64}; - - const auto inPrecisions = ::testing::Combine( - ::testing::Values(InferenceEngine::Precision::FP32), - ::testing::Values(InferenceEngine::Precision::I32), - ::testing::Values(InferenceEngine::Precision::FP32)); - - const auto nmsParams = ::testing::Combine( - ::testing::ValuesIn(inShapeParams), - inPrecisions, - ::testing::ValuesIn(maxOutBoxPerClass), - ::testing::ValuesIn(threshold), // IOU threshold - ::testing::ValuesIn(threshold), // Score threshold - ::testing::ValuesIn(sigmaThreshold), - ::testing::ValuesIn(encodType), - ::testing::ValuesIn(sortResDesc), - ::testing::ValuesIn(outType), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - - INSTANTIATE_TEST_SUITE_P(smoke_NmsLayerTest, NmsLayerTest, nmsParams, NmsLayerTest::getTestCaseName); -} // namespace - diff --git a/src/tests/functional/inference_engine/serialization/single_layer/nonzero.cpp b/src/tests/functional/inference_engine/serialization/single_layer/nonzero.cpp deleted file mode 100644 index db8e05632b2..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/nonzero.cpp +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/nonzero.hpp" - -using namespace ngraph; -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(NonZeroLayerTest, Serialize) { - Serialize(); -} - -std::vector inputDims = { - {7}, {1000}, {3, 5}, {65, 33}, {33, 65}, - {1, 1000}, {223, 217, 21}, {3, 4, 5, 1}, {3, 4, 1, 5, 1}}; - -std::vector inputPrecisions = { - InferenceEngine::Precision::BOOL, InferenceEngine::Precision::U8, - InferenceEngine::Precision::FP32, InferenceEngine::Precision::I32, -}; - -ConfigMap config; - -INSTANTIATE_TEST_SUITE_P( - smoke_NonZeroLayerTest, NonZeroLayerTest, - ::testing::Combine(::testing::ValuesIn(inputDims), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(config))); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/normalize_l2.cpp b/src/tests/functional/inference_engine/serialization/single_layer/normalize_l2.cpp deleted file mode 100644 index b4963a62c94..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/normalize_l2.cpp +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/normalize_l2.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace InferenceEngine; -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(NormalizeL2LayerTest, Serialize) { - Serialize(); -} - -const std::vector> axes = { - {1}, -}; -const std::vector eps = { 1e-4f }; - -const std::vector epsMode = { - ngraph::op::EpsMode::ADD, - ngraph::op::EpsMode::MAX, -}; - -const std::vector netPrecisions = { - Precision::FP32, - Precision::BF16 -}; - -INSTANTIATE_TEST_SUITE_P(smoke_NormalizeL2Serialization, NormalizeL2LayerTest, - testing::Combine( - testing::ValuesIn(axes), - testing::ValuesIn(eps), - testing::ValuesIn(epsMode), - testing::Values(std::vector{1, 32, 17}), - testing::ValuesIn(netPrecisions), - testing::Values(CommonTestUtils::DEVICE_CPU)), - NormalizeL2LayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/not_equal.cpp b/src/tests/functional/inference_engine/serialization/single_layer/not_equal.cpp deleted file mode 100644 index 082b85eaa68..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/not_equal.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "comparison_ops.hpp" - -using namespace LayerTestsDefinitions; -using namespace LayerTestsDefinitions::ComparisonParams; - -namespace { -TEST_P(ComparisonLayerTest, Serialize) { - Serialize(); - } - -ComparisionOpsData data = { - // inputsShape - { - {{1}, {{1}, {17}, {1, 1}, {2, 18}, {1, 1, 2}, {2, 2, 3}, {1, 1, 2, 3}}}, - {{5}, {{1}, {1, 1}, {2, 5}, {1, 1, 1}, {2, 2, 5}}}, - {{2, 200}, {{1}, {200}, {1, 200}, {2, 200}, {2, 2, 200}}}, - {{1, 3, 20}, {{20}, {2, 1, 1}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {2, 1, 3, 4}}}, - {{2, 17, 3, 4}, {{4}, {1, 3, 4}, {141, 1, 3, 4}}}, - {{2, 1, 1, 3, 1}, {{1}, {1, 3, 4}, {2, 1, 3, 4}, {1, 1, 1, 1, 1}}}, - }, - // inputsPrecisions - { - InferenceEngine::Precision::FP64, - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U32, - InferenceEngine::Precision::BOOL, - }, - // secondIinputsType - { - ngraph::helpers::InputLayerType::CONSTANT, - ngraph::helpers::InputLayerType::PARAMETER, - }, - // additionalConfig - {}, - // opType - ngraph::helpers::ComparisonTypes::NOT_EQUAL, - // ieInputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // ieOutputPrecision - InferenceEngine::Precision::UNSPECIFIED, - // deviceName - CommonTestUtils::DEVICE_CPU, -}; - -const auto SerializeNotEqualTestParams = ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(data.inputShapes)), - ::testing::ValuesIn(data.inputsPrecisions), - ::testing::Values(data.opType), - ::testing::ValuesIn(data.secondInputTypes), - ::testing::Values(data.ieInputPrecision), - ::testing::Values(data.ieOutputPrecision), - ::testing::Values(data.deviceName), - ::testing::Values(data.additional_config)); - -INSTANTIATE_TEST_SUITE_P(smoke_CompareWithRefs, ComparisonLayerTest, SerializeNotEqualTestParams, ComparisonLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/one_hot.cpp b/src/tests/functional/inference_engine/serialization/single_layer/one_hot.cpp deleted file mode 100644 index 0f81604989b..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/one_hot.cpp +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/one_hot.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(OneHotLayerTest, Serialize) { Serialize(); } - -const std::vector netPrecisions = { - InferenceEngine::Precision::I32 }; - -const std::vector argDepthType_IC = { ngraph::element::i32 }; -const std::vector argDepth_IC = { 5, 1017 }; -const std::vector argSetType_IC = { ngraph::element::i32, ngraph::element::i64 }; -const std::vector argOnValue_IC = { 1, -29 }; -const std::vector argOffValue_IC = { -1, 127 }; -const std::vector argAxis_IC = {0, 1, -1}; -const std::vector> inputShapes_IC = {{4, 5}, {3, 7}}; - -const auto oneHotParams = testing::Combine( - testing::ValuesIn(argDepthType_IC), - testing::ValuesIn(argDepth_IC), - testing::ValuesIn(argSetType_IC), - testing::ValuesIn(argOnValue_IC), - testing::ValuesIn(argOffValue_IC), - testing::ValuesIn(argAxis_IC), - testing::ValuesIn(netPrecisions), - testing::ValuesIn(inputShapes_IC), - testing::Values(CommonTestUtils::DEVICE_CPU) -); - -INSTANTIATE_TEST_SUITE_P(smoke_OneHotConstSerialization, OneHotLayerTest, oneHotParams, - OneHotLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/pad.cpp b/src/tests/functional/inference_engine/serialization/single_layer/pad.cpp deleted file mode 100644 index c42a4c87e0f..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/pad.cpp +++ /dev/null @@ -1,40 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/pad.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(PadLayerTest, Serialize) { Serialize(); } - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP16}; - -const std::vector> padsBegin2D = { - {0, 0}, {1, 1}, {2, 0}, {0, 3}}; -const std::vector> padsEnd2D = { - {0, 0}, {1, 1}, {0, 1}, {3, 2}}; -const std::vector argPadValue = {0.f, 1.f, 2.f, -1.f}; - -const std::vector padMode = { - ngraph::helpers::PadMode::EDGE, ngraph::helpers::PadMode::REFLECT, - ngraph::helpers::PadMode::SYMMETRIC}; - -const auto pad2DConstparams = testing::Combine( - testing::ValuesIn(padsBegin2D), testing::ValuesIn(padsEnd2D), - testing::ValuesIn(argPadValue), - testing::Values(ngraph::helpers::PadMode::CONSTANT), - testing::ValuesIn(netPrecisions), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Layout::ANY), - testing::Values(std::vector{13, 5}), - testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P(smoke_Pad2DConstSerialization, PadLayerTest, pad2DConstparams, - PadLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/pooling.cpp b/src/tests/functional/inference_engine/serialization/single_layer/pooling.cpp deleted file mode 100644 index 6f81ddc107a..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/pooling.cpp +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/pooling.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(PoolingLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16 - }; - - /* ============= POOLING ============= */ - const std::vector> kernels = {{3, 3}, - {3, 5}}; - const std::vector> strides = {{1, 1}, - {1, 2}}; - const std::vector> padBegins = {{0, 0}, - {0, 2}}; - const std::vector> padEnds = {{0, 0}, - {0, 2}}; - - const std::vector roundingTypes = { - ngraph::op::RoundingType::FLOOR, - ngraph::op::RoundingType::CEIL - }; - - const std::vector padTypes = { - ngraph::op::PadType::EXPLICIT, - ngraph::op::PadType::SAME_UPPER, - ngraph::op::PadType::VALID - }; - - const std::vector inputShape = {511, 11, 13, 15}; - const std::vector excludePad = {true, false}; - - /* ============= AVERAGE POOLING ============= */ - - const auto avgExcludePadParams = ::testing::Combine( - ::testing::Values(ngraph::helpers::PoolingTypes::AVG), - ::testing::ValuesIn(kernels), - ::testing::ValuesIn(strides), - ::testing::ValuesIn(padBegins), - ::testing::ValuesIn(padEnds), - ::testing::ValuesIn(roundingTypes), - ::testing::ValuesIn(padTypes), - ::testing::Values(excludePad[0])); - - INSTANTIATE_TEST_SUITE_P(smoke_AvgPoolExcluePad, PoolingLayerTest, - ::testing::Combine( - avgExcludePadParams, - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(inputShape), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - PoolingLayerTest::getTestCaseName); - - const auto avgPadParams = ::testing::Combine( - ::testing::Values(ngraph::helpers::PoolingTypes::AVG), - ::testing::ValuesIn(kernels), - ::testing::ValuesIn(strides), - ::testing::ValuesIn(padBegins), - ::testing::ValuesIn(padEnds), - ::testing::ValuesIn(roundingTypes), - ::testing::ValuesIn(padTypes), - ::testing::Values(excludePad[1])); - - INSTANTIATE_TEST_SUITE_P(smoke_AvgPool, PoolingLayerTest, - ::testing::Combine( - avgPadParams, - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(inputShape), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - PoolingLayerTest::getTestCaseName); -} // namespace - diff --git a/src/tests/functional/inference_engine/serialization/single_layer/prelu.cpp b/src/tests/functional/inference_engine/serialization/single_layer/prelu.cpp deleted file mode 100644 index a28d5b59e53..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/prelu.cpp +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include "shared_test_classes/single_layer/activation.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; -using namespace ngraph::helpers; -namespace { - TEST_P(ActivationLayerTest, Serialize) { - Serialize(); - } - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16 -}; - -const std::map>> activationTypes = { - {ActivationTypes::PReLu, {{-0.01f}}}, -}; - -std::map, std::vector>> basic = { - {{1, 50}, {{}}}, - {{1, 128}, {{}}}, -}; - -const auto basicCases = ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(activationTypes)), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::ValuesIn(CommonTestUtils::combineParams(basic)), - ::testing::Values(CommonTestUtils::DEVICE_CPU) -); - -INSTANTIATE_TEST_SUITE_P(smoke_ActivationPreluSerialization, - ActivationLayerTest, basicCases, ActivationLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/prior_box.cpp b/src/tests/functional/inference_engine/serialization/single_layer/prior_box.cpp deleted file mode 100644 index 0e70bd80b01..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/prior_box.cpp +++ /dev/null @@ -1,103 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/prior_box.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(PriorBoxLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U16 - }; - const std::vector> min_sizes = { - {16.f, 32.f} - }; - - const std::vector> max_sizes = { - {256.f, 512.f} - }; - - const std::vector> aspect_ratios = { - {0.66f, 1.56f} - }; - - const std::vector> densities = { - {0.55f} - }; - - const std::vector> fixed_ratios = { - {0.88f} - }; - - const std::vector> fixed_sizes = { - {1.25f} - }; - - const std::vector clips = { - true, false - }; - - const std::vector flips = { - true, false - }; - - const std::vector steps = { - 1.0f, 2.0f - }; - - const std::vector offsets = { - 0.0f, 0.5f - }; - - const std::vector> variances = { - {2.22f, 3.14f} - }; - - const std::vector scale_all_sizes = { - true, false - }; - - const std::vector min_max_aspect_ratios_order = { - true, false - }; - - const std::vector inputShape = {128, 128}; - const std::vector imageShape = {50, 50}; - - const auto layerSpecificParams = ::testing::Combine( - ::testing::ValuesIn(min_sizes), - ::testing::ValuesIn(max_sizes), - ::testing::ValuesIn(aspect_ratios), - ::testing::ValuesIn(densities), - ::testing::ValuesIn(fixed_ratios), - ::testing::ValuesIn(fixed_sizes), - ::testing::ValuesIn(clips), - ::testing::ValuesIn(flips), - ::testing::ValuesIn(steps), - ::testing::ValuesIn(offsets), - ::testing::ValuesIn(variances), - ::testing::ValuesIn(scale_all_sizes), - ::testing::ValuesIn(min_max_aspect_ratios_order)); - - INSTANTIATE_TEST_SUITE_P(smoke_PriorBox_Basic, PriorBoxLayerTest, - ::testing::Combine( - layerSpecificParams, - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(inputShape), - ::testing::Values(imageShape), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - PriorBoxLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/prior_box_clustered.cpp b/src/tests/functional/inference_engine/serialization/single_layer/prior_box_clustered.cpp deleted file mode 100644 index e8efd85bcf1..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/prior_box_clustered.cpp +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/prior_box_clustered.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(PriorBoxClusteredLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16 - }; - - const std::vector> widths = { - { 5.12f, 14.6f, 13.5f }, - { 7.0f, 8.2f, 33.39f } - }; - - const std::vector> heights = { - { 15.12f, 15.6f, 23.5f }, - { 10.0f, 16.2f, 36.2f } - }; - - const std::vector step_widths = { - 0.0f, 2.0f - }; - - const std::vector step_heights = { - 0.0f, 1.5f - }; - - const std::vector step = { - 0.0f - }; - - const std::vector offsets = { - 0.5f - }; - - const std::vector> variances = { - { 0.1f, 0.1f, 0.2f, 0.2f } - }; - - const std::vector clips = { - true, false - }; - - const std::vector inputShape = {4, 4}; - const std::vector imageShape = {50, 50}; - - const auto layerSpeficParams = ::testing::Combine( - ::testing::ValuesIn(widths), - ::testing::ValuesIn(heights), - ::testing::ValuesIn(clips), - ::testing::ValuesIn(step_widths), - ::testing::ValuesIn(step_heights), - ::testing::ValuesIn(step), - ::testing::ValuesIn(offsets), - ::testing::ValuesIn(variances)); - - INSTANTIATE_TEST_SUITE_P(smoke_PriorBoxClustered_Basic, PriorBoxClusteredLayerTest, - ::testing::Combine( - layerSpeficParams, - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(inputShape), - ::testing::Values(imageShape), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - PriorBoxClusteredLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/reduce_ops.cpp b/src/tests/functional/inference_engine/serialization/single_layer/reduce_ops.cpp deleted file mode 100644 index 7c3b030d7c9..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/reduce_ops.cpp +++ /dev/null @@ -1,177 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/reduce_ops.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(ReduceOpsLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U8, - InferenceEngine::Precision::I8, -}; - -const std::vector keepDims = { - true, - false, -}; - -std::vector opTypes = { - CommonTestUtils::OpType::SCALAR, - CommonTestUtils::OpType::VECTOR, -}; - -const std::vector reductionTypes = { - ngraph::helpers::ReductionType::Mean, - ngraph::helpers::ReductionType::Min, - ngraph::helpers::ReductionType::Max, - ngraph::helpers::ReductionType::Sum, - ngraph::helpers::ReductionType::Prod, - ngraph::helpers::ReductionType::L1, - ngraph::helpers::ReductionType::L2, -}; - -const std::vector reductionLogicalTypes = { - ngraph::helpers::ReductionType::LogicalOr, - ngraph::helpers::ReductionType::LogicalAnd -}; - -const std::vector> inputShapesOneAxis = { - std::vector{10, 20, 30, 40}, - std::vector{3, 5, 7, 9}, - std::vector{10}, -}; - -const std::vector> inputShapes = { - std::vector{10, 20, 30, 40}, - std::vector{3, 5, 7, 9}, -}; - -const std::vector> axes = { - {0}, - {1}, - {2}, - {3}, - {0, 1}, - {0, 2}, - {0, 3}, - {1, 2}, - {1, 3}, - {2, 3}, - {0, 1, 2}, - {0, 1, 3}, - {0, 2, 3}, - {1, 2, 3}, - {0, 1, 2, 3}, - {1, -1} -}; - -const auto paramsOneAxis = testing::Combine( - testing::Values(std::vector{0}), - testing::ValuesIn(opTypes), - testing::ValuesIn(keepDims), - testing::ValuesIn(reductionTypes), - testing::Values(netPrecisions[0]), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Layout::ANY), - testing::ValuesIn(inputShapesOneAxis), - testing::Values(CommonTestUtils::DEVICE_CPU) -); - -const auto paramsOneAxisLogical = testing::Combine( - testing::Values(std::vector{0}), - testing::ValuesIn(opTypes), - testing::ValuesIn(keepDims), - testing::ValuesIn(reductionLogicalTypes), - testing::Values(InferenceEngine::Precision::BOOL), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Layout::ANY), - testing::ValuesIn(inputShapesOneAxis), - testing::Values(CommonTestUtils::DEVICE_CPU) -); - -const auto params_Axes = testing::Combine( - testing::ValuesIn(axes), - testing::Values(opTypes[1]), - testing::ValuesIn(keepDims), - testing::Values(reductionTypes[0]), - testing::Values(netPrecisions[0]), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Layout::ANY), - testing::ValuesIn(inputShapes), - testing::Values(CommonTestUtils::DEVICE_CPU) -); - -const auto params_ReductionTypes = testing::Combine( - testing::Values(std::vector{0, 1, 3}), - testing::Values(opTypes[1]), - testing::ValuesIn(keepDims), - testing::ValuesIn(reductionTypes), - testing::ValuesIn(netPrecisions), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Layout::ANY), - testing::Values(std::vector{2, 9, 2, 9}), - testing::Values(CommonTestUtils::DEVICE_CPU) -); - -const auto params_ReductionTypesLogical = testing::Combine( - testing::Values(std::vector{0, 1, 3}), - testing::Values(opTypes[1]), - testing::ValuesIn(keepDims), - testing::ValuesIn(reductionLogicalTypes), - testing::Values(InferenceEngine::Precision::BOOL), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Precision::UNSPECIFIED), - testing::Values(InferenceEngine::Layout::ANY), - testing::Values(std::vector{2, 9, 2, 9}), - testing::Values(CommonTestUtils::DEVICE_CPU) -); - -INSTANTIATE_TEST_SUITE_P( - smoke_ReduceOneAxis_Serialization, - ReduceOpsLayerTest, - paramsOneAxis, - ReduceOpsLayerTest::getTestCaseName -); - -INSTANTIATE_TEST_SUITE_P( - smoke_ReduceLogicalOneAxis_Serialization, - ReduceOpsLayerTest, - paramsOneAxisLogical, - ReduceOpsLayerTest::getTestCaseName -); - -INSTANTIATE_TEST_SUITE_P( - smoke_ReduceAxes_Serialization, - ReduceOpsLayerTest, - params_Axes, - ReduceOpsLayerTest::getTestCaseName -); - -INSTANTIATE_TEST_SUITE_P( - smoke_Reduce_ReductionTypes_Serialization, - ReduceOpsLayerTest, - params_ReductionTypes, - ReduceOpsLayerTest::getTestCaseName -); - -INSTANTIATE_TEST_SUITE_P( - smoke_ReduceLogical_ReductionTypes_Serialization, - ReduceOpsLayerTest, - params_ReductionTypesLogical, - ReduceOpsLayerTest::getTestCaseName -); -} // namespace \ No newline at end of file diff --git a/src/tests/functional/inference_engine/serialization/single_layer/region_yolo.cpp b/src/tests/functional/inference_engine/serialization/single_layer/region_yolo.cpp deleted file mode 100644 index d2a8e50d8b7..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/region_yolo.cpp +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/region_yolo.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(RegionYoloLayerTest, Serialize) { - Serialize(); - } - - - const std::vector inShapes_v3 = { - {1, 255, 52, 52}, - {1, 255, 26, 26}, - {1, 255, 13, 13} - }; - const std::vector> masks = { - {0, 1, 2}, - {3, 4, 5}, - {6, 7, 8} - }; - - const std::vector do_softmax = {true, false}; - const std::vector classes = {80, 20}; - const std::vector num_regions = {5, 9}; - const size_t coords = 4; - const int start_axis = 1; - const int end_axis = 3; - - INSTANTIATE_TEST_SUITE_P(smoke_RegionYolov3Serialization, RegionYoloLayerTest, - ::testing::Combine( - ::testing::ValuesIn(inShapes_v3), - ::testing::Values(classes[0]), - ::testing::Values(coords), - ::testing::Values(num_regions[1]), - ::testing::Values(do_softmax[1]), - ::testing::Values(masks[2]), - ::testing::Values(start_axis), - ::testing::Values(end_axis), - ::testing::Values(InferenceEngine::Precision::FP32), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - RegionYoloLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/reshape.cpp b/src/tests/functional/inference_engine/serialization/single_layer/reshape.cpp deleted file mode 100644 index f574282951f..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/reshape.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/reshape.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(ReshapeLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16 - }; - - INSTANTIATE_TEST_SUITE_P(smoke_ReshapeSerialization, ReshapeLayerTest, - ::testing::Combine( - ::testing::Values(true), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({30, 30, 30, 30})), - ::testing::Values(std::vector({30, 30, 30, 30})), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(std::map({{CONFIG_KEY(DYN_BATCH_ENABLED), CONFIG_VALUE(YES)}}))), - ReshapeLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/result.cpp b/src/tests/functional/inference_engine/serialization/single_layer/result.cpp deleted file mode 100644 index 753a013dcc1..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/result.cpp +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/result.hpp" - -using namespace ngraph; -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(ResultLayerTest, Serialize) { - Serialize(); -} - -std::vector inputDims = { - {7}, {1000}, {3, 5}, {65, 33}, {33, 65}, - {1, 1000}, {223, 217, 21}, {3, 4, 5, 1}, {3, 4, 1, 5, 1}}; - -std::vector inputPrecisions = { - InferenceEngine::Precision::U8, InferenceEngine::Precision::FP32, - InferenceEngine::Precision::I32, -}; - -ConfigMap config; - -INSTANTIATE_TEST_SUITE_P( - smoke_ResultLayerTest, ResultLayerTest, - ::testing::Combine(::testing::ValuesIn(inputDims), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(config))); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/scatter_elements_update.cpp b/src/tests/functional/inference_engine/serialization/single_layer/scatter_elements_update.cpp deleted file mode 100644 index 19ee960c3f6..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/scatter_elements_update.cpp +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include - -#include "shared_test_classes/single_layer/scatter_elements_update.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; -using namespace ngraph::opset3; - -namespace { -TEST_P(ScatterElementsUpdateLayerTest, Serialize) { - Serialize(); -} -// map> -std::map, std::map, std::vector>> axesShapeInShape { - {{10, 12, 15}, {{{1, 2, 4}, {0, 1, 2}}, {{2, 2, 2}, {-1, -2, -3}}}}, - {{15, 9, 8, 12}, {{{1, 2, 2, 2}, {0, 1, 2, 3}}, {{1, 2, 1, 4}, {-1, -2, -3, -4}}}}, - {{9, 9, 8, 8, 11, 10}, {{{1, 2, 1, 2, 1, 2}, {5, -3}}}}, -}; -// index value should not be random data -const std::vector> idxValue = { - {1, 0, 4, 6, 2, 3, 7, 5} -}; - -const std::vector inputPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, -}; - -const std::vector idxPrecisions = { - InferenceEngine::Precision::I32, - InferenceEngine::Precision::I64, -}; - -const auto ScatterEltUpdateCases = ::testing::Combine( - ::testing::ValuesIn(ScatterElementsUpdateLayerTest::combineShapes(axesShapeInShape)), - ::testing::ValuesIn(idxValue), - ::testing::ValuesIn(inputPrecisions), - ::testing::ValuesIn(idxPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU) -); - -INSTANTIATE_TEST_SUITE_P(smoke_ScatterEltsUpdateSerialization, ScatterElementsUpdateLayerTest, - ScatterEltUpdateCases, ScatterElementsUpdateLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/scatter_nd_update.cpp b/src/tests/functional/inference_engine/serialization/single_layer/scatter_nd_update.cpp deleted file mode 100644 index 84b57bc04ae..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/scatter_nd_update.cpp +++ /dev/null @@ -1,50 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include - -#include "shared_test_classes/single_layer/scatter_ND_update.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(ScatterNDUpdateLayerTest, Serialize) { - Serialize(); -} - -const std::vector inputPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, -}; - -const std::vector idxPrecisions = { - InferenceEngine::Precision::I32, - InferenceEngine::Precision::I64, -}; -// map> -// updateShape is gotten from inputShape and indicesShape -std::map, std::map, std::vector>> - sliceSelectInShape{ - {{10, 9, 9, 11}, - {{{4, 1}, {1, 3, 5, 7}}, - {{1, 2}, {4, 6}}, - {{2, 3}, {0, 1, 1, 2, 2, 2}}, - {{1, 4}, {5, 5, 4, 9}}}}, - {{10, 9, 10, 9, 10}, {{{2, 2, 1}, {5, 6, 2, 8}}, {{2, 3}, {0, 4, 6, 5, 7, 1}}}}, - }; - -const auto ScatterNDUpdateCases = ::testing::Combine( - ::testing::ValuesIn(ScatterNDUpdateLayerTest::combineShapes(sliceSelectInShape)), - ::testing::ValuesIn(inputPrecisions), - ::testing::ValuesIn(idxPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P( - smoke_ScatterNDUpdateLayerTestSerialization, - ScatterNDUpdateLayerTest, - ScatterNDUpdateCases, - ScatterNDUpdateLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/scatter_update.cpp b/src/tests/functional/inference_engine/serialization/single_layer/scatter_update.cpp deleted file mode 100644 index 81036e4f092..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/scatter_update.cpp +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include - -#include "shared_test_classes/single_layer/scatter_update.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; -using namespace ngraph::opset8; - -namespace { -TEST_P(ScatterUpdateLayerTest, Serialize) { - Serialize(); -} - -const std::vector inputPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, -}; - -const std::vector idxPrecisions = { - InferenceEngine::Precision::I32, - InferenceEngine::Precision::I64, -}; - -// map> -std::map, std::map, std::vector>> axesShapeInShape { - {{10, 16, 12, 15}, {{{2, 4}, {0, 1, 2, 3}}, {{8}, {-1, -2, -3, -4}}}}, - {{10, 9, 10, 9, 10}, {{{8}, {-3, -1, 0, 2, 4}}, {{4, 2}, {-2, 2}}}}, -}; -//indices should not be random value -const std::vector> idxValue = { - {0, 2, 4, 6, 1, 3, 5, 7} -}; - -const auto ScatterUpdateCase = ::testing::Combine( - ::testing::ValuesIn(ScatterUpdateLayerTest::combineShapes(axesShapeInShape)), - ::testing::ValuesIn(idxValue), - ::testing::ValuesIn(inputPrecisions), - ::testing::ValuesIn(idxPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU) -); - -INSTANTIATE_TEST_SUITE_P(smoke_ScatterUpdate, ScatterUpdateLayerTest, ScatterUpdateCase, ScatterUpdateLayerTest::getTestCaseName); - -} // namespace - diff --git a/src/tests/functional/inference_engine/serialization/single_layer/select.cpp b/src/tests/functional/inference_engine/serialization/single_layer/select.cpp deleted file mode 100644 index 0aef6e8171d..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/select.cpp +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/select.hpp" - -#include -using namespace LayerTestsDefinitions; - -const std::vector inputPrecision = { - InferenceEngine::Precision::I8, InferenceEngine::Precision::I16, - InferenceEngine::Precision::I32, InferenceEngine::Precision::FP16, - InferenceEngine::Precision::FP32}; - -const std::vector>> noneShapes = { - {{2, 3, 4, 5, 6}, {2, 3, 4, 5, 6}, {2, 3, 4, 5, 6}}}; - -const auto noneCases = ::testing::Combine( - ::testing::ValuesIn(noneShapes), ::testing::ValuesIn(inputPrecision), - ::testing::Values(ngraph::op::AutoBroadcastType::NONE), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -const std::vector>> numpyShapes = { - {{5, 1, 2, 1}, {8, 1, 9, 1, 1}, {5, 1, 2, 1}}}; - -const auto numpyCases = ::testing::Combine( - ::testing::ValuesIn(numpyShapes), ::testing::ValuesIn(inputPrecision), - ::testing::Values(ngraph::op::AutoBroadcastType::NUMPY), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -TEST_P(SelectLayerTest, Serialize) { - Serialize(); -} - -INSTANTIATE_TEST_SUITE_P(smoke_Serialization_SelectLayerTest_none, - SelectLayerTest, noneCases, - SelectLayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_Serialization_SelectLayerTest_numpy, - SelectLayerTest, numpyCases, - SelectLayerTest::getTestCaseName); diff --git a/src/tests/functional/inference_engine/serialization/single_layer/shuffle_channels.cpp b/src/tests/functional/inference_engine/serialization/single_layer/shuffle_channels.cpp deleted file mode 100644 index 2583ff4b4da..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/shuffle_channels.cpp +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/shuffle_channels.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(ShuffleChannelsLayerTest, Serialize) { - Serialize(); - } - -const std::vector netPrecisions = { - InferenceEngine::Precision::I8, - InferenceEngine::Precision::U8, - InferenceEngine::Precision::I16, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::FP32 -}; - -const std::vector axes = {0, 1, 2, 3}; -const std::vector negativeAxes = {-4, -3, -2, -1}; -const std::vector groups = {1, 2, 3}; - -const auto shuffleChannelsParams4D = ::testing::Combine( - ::testing::ValuesIn(axes), - ::testing::ValuesIn(groups) -); - -const auto shuffleChannelsParamsNegativeAxis4D = ::testing::Combine( - ::testing::ValuesIn(negativeAxes), - ::testing::ValuesIn(groups) -); - -INSTANTIATE_TEST_SUITE_P(smoke_ShuffleChannelsSerialization, ShuffleChannelsLayerTest, - ::testing::Combine( - shuffleChannelsParams4D, - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({6, 6, 6, 6})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - ShuffleChannelsLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/slice.cpp b/src/tests/functional/inference_engine/serialization/single_layer/slice.cpp deleted file mode 100644 index 8e457a516e1..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/slice.cpp +++ /dev/null @@ -1,131 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/slice.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; -using namespace ov::test; - -namespace { -TEST_P(Slice8LayerTest, Serialize) { - serialize(); -} - -const std::vector inputPrecisions = { - ElementType::f32, - ElementType::bf16, - ElementType::i8 -}; - -const std::vector inputPrecisionsOther = { - ElementType::i64, - ElementType::i32, - ElementType::i16, - ElementType::u8 -}; - -std::vector staticParams = { - Slice8SpecificParams{ {{{}, {{ 16 }}}}, { 4 }, { 12 }, { 1 }, { 0 } }, - Slice8SpecificParams{ {{{}, {{ 16 }}}}, { 0 }, { 8 }, { 2 }, { 0 } }, - Slice8SpecificParams{ {{{}, {{ 20, 10, 5 }}}}, { 0, 0}, { 10, 20}, { 1, 1 }, { 1, 0 } }, - Slice8SpecificParams{ {{{}, {{ 1, 2, 12, 100 }}}}, { 0, 1, 0, 1 }, { 1, 2, 5, 100 }, { 1, 1, 1, 10 }, {} }, - Slice8SpecificParams{ {{{}, {{ 1, 12, 100 }}}}, { 0, 9, 0 }, { 1, 11, 1 }, { 1, 1, 1 }, { 0, 1, -1 } }, - Slice8SpecificParams{ {{{}, {{ 1, 12, 100 }}}}, { 0, 1, 0 }, { 10, -1, 10 }, { 1, 1, 1 }, { -3, -2, -1} }, - Slice8SpecificParams{ {{{}, {{ 2, 12, 100 }}}}, { 1, 12, 100 }, { 0, 7, 0 }, { -1, -1, -1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 2, 12, 100 }}}}, { 1, 4, 99 }, { 0, 9, 0 }, { -1, 2, -1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 2, 12, 100 }}}}, { -1, -1, -1 }, { 0, 4, 0 }, { -1, -2, -1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 2, 12, 100 }}}}, { -1, -1, -1 }, { 0, 0, 4 }, { -1, -1, -1 }, {2, 0, 1} }, - Slice8SpecificParams{ {{{}, {{ 2, 12, 100 }}}}, { 0, 0, 4 }, { -5, -1, -1 }, { 1, 2, 1 }, {2, 0, 1} }, - Slice8SpecificParams{ {{{}, {{ 2, 2, 2, 2 }}}}, { 0, 0, 0, 0 }, { 2, 2, 2, 2 }, { 1, 1, 1, 1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 2, 2, 2, 2 }}}}, { 1, 1, 1, 1 }, { 2, 2, 2, 2 }, { 1, 1, 1, 1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 2, 2, 4, 3 }}}}, { 0, 0, 0, 0 }, { 2, 2, 4, 3 }, { 1, 1, 2, 1 }, { -4, 1, -2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 2, 2, 4, 2 }}}}, { 1, 0, 0, 1 }, { 2, 2, 4, 2 }, { 1, 1, 2, 1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 1, 2, 4, 2 }}}}, { 0, 1, 0, 1 }, { 10, 2, 4, 2 }, { 1, 1, 2, 1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 1, 2, 4, 2 }}}}, { 1, 0, 1, 0 }, { 2, 4, 2, 10 }, { 1, 2, 1, 1 }, { -1, -2, -3, -4 } }, - Slice8SpecificParams{ {{{}, {{ 10, 2, 4, 2 }}}}, { 9, 1, 3, 0 }, { 0, 0, 0, 1 }, { -1, -1, -1, 1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 10, 2, 4, 2 }}}}, { 19, 1, -1, 0 }, { -10, 0, 0, -1 }, { -1, -1, -1, 1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 3, 2, 4, 200 }}}}, { 0, 1, -1, -1 }, { 3, 2, 0, 0 }, { 1, 1, -2, -1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 2, 4, 5, 5, 68 }}}}, { 0, 1, 0, 0, 0 }, { - std::numeric_limits::max(), - std::numeric_limits::max(), - std::numeric_limits::max(), - std::numeric_limits::max(), - std::numeric_limits::max() }, { 1, 1, 1, 1, 16 }, {} }, - Slice8SpecificParams{ {{{}, {{ 10, 12 }}}}, { -1, 1 }, { -9999, 10 }, { -1, 1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 5, 5, 5, 5 }}}}, { -1, 0, -1, 0 }, { -50, -1, -60, -1 }, { -1, 1, -1, 1 }, {} }, - Slice8SpecificParams{ {{{}, {{ 1, 5, 32, 32 }}}}, { 0, 2, 5, 4 }, { 1, 4, 28, 27 }, { 1, 1, 1, 1 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 1, 5, 32, 20 }}}}, { 0, 1, 0, 0 }, { 1, 3, 32, 20 }, { 1, 1, 1, 1 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 2, 5, 32, 20 }}}}, { 0, 0, 10, 0 }, { 1, 3, 20, 20 }, { 1, 1, 1, 1 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 1, 5, 32, 32 }}}}, { 0, 0, 20, 20 }, { 1, 5, 25, 26 }, { 1, 1, 1, 2 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 2, 5, 32, 32 }}}}, { 0, 0, 0, 20 }, { 1, 2, 30, 30 }, { 1, 1, 2, 1 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 1, 5, 32, 20 }}}}, { 0, 0, 2, 10 }, { 1, 3, 32, 20 }, { 1, 1, 1, 1 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 2, 5, 32, 32 }}}}, { 0, 1, 0, 10 }, { 1, 5, 32, 30 }, { 1, 1, 1, 1 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 1, 5, 32, 20 }}}}, { 0, 1, 2, 10 }, { 1, 5, 32, 18 }, { 1, 1, 1, 2 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 2, 8, 32, 20 }}}}, { 0, 0, 2, 10 }, { 1, 8, 32, 18 }, { 1, 2, 1, 2 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{}, {{ 2, 8, 32, 20 }}}}, { 0, -20, -15 }, { 2, -5, 3 }, { 1, 1, 1 }, { 0, 2, 1 } } -}; - -INSTANTIATE_TEST_SUITE_P(smoke_Slice8Serialization_static, Slice8LayerTest, - ::testing::Combine( - ::testing::ValuesIn(staticParams), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(ElementType::undefined), - ::testing::Values(ElementType::undefined), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(std::map())), - Slice8LayerTest::getTestCaseName); - -INSTANTIATE_TEST_SUITE_P(smoke_Slice8Serialization_PrecisionTransformation, Slice8LayerTest, - ::testing::Combine( - ::testing::Values(staticParams[0]), - ::testing::ValuesIn(inputPrecisionsOther), - ::testing::Values(ElementType::undefined), - ::testing::Values(ElementType::undefined), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(std::map())), - Slice8LayerTest::getTestCaseName); - -std::vector dynamicParams = { - Slice8SpecificParams{ {{{ -1 }, {{ 8 }, { 16 }}}}, { 4 }, { 12 }, { 1 }, { 0 } }, - Slice8SpecificParams{ {{{ ov::Dimension(2, 20) }, {{ 5 }, { 15 }}}}, { 0 }, { 8 }, { 2 }, { 0 } }, - Slice8SpecificParams{ {{{ -1, -1, -1 }, {{ 20, 10, 5 }, {5, 10, 20}}}}, { 0, 0}, { 10, 20}, { 1, 1 }, { 1, 0 } }, - Slice8SpecificParams{ {{{ -1, -1, -1, -1 }, {{ 1, 2, 12, 100 }}}}, { 0, 1, 0, 1 }, { 1, 2, 5, 100 }, { 1, 1, 1, 10 }, {} }, - Slice8SpecificParams{ {{{ -1, ov::Dimension(2, 20), -1 }, {{ 1, 12, 100 }, { 2, 12, 100 }}}}, { 0, 9, 0 }, { 1, 11, 1 }, { 1, 1, 1 }, {} }, - Slice8SpecificParams{ {{{ ov::Dimension(1, 5), ov::Dimension(1, 5), ov::Dimension(1, 5), ov::Dimension(1, 5) }, - {{ 2, 2, 2, 2 }, { 2, 2, 4, 3 }, { 2, 2, 4, 2 }, { 1, 2, 4, 2 }}}}, - { 0, 0, 0, 0 }, { 2, 2, 2, 2 }, { 1, 1, 1, 1 }, {} }, - Slice8SpecificParams{ {{{ -1, ov::Dimension(1, 5), ov::Dimension(1, 5), -1 }, {{ 10, 2, 4, 2 }, { 10, 4, 2, 2 }}}}, - { 9, 1, 3, 0 }, { 0, 0, 0, 1 }, { -1, -1, -1, 1 }, {} }, - Slice8SpecificParams{ {{{ -1, ov::Dimension(1, 5), -1, -1, ov::Dimension(30, 70) }, {{ 2, 4, 5, 5, 68 }, { 2, 3, 7, 7, 33 }}}}, - { 0, 1, 0, 0, 0 }, { - std::numeric_limits::max(), - std::numeric_limits::max(), - std::numeric_limits::max(), - std::numeric_limits::max(), - std::numeric_limits::max() }, { 1, 1, 1, 1, 16 }, {} }, - Slice8SpecificParams{ {{{ov::Dimension(1, 5), ov::Dimension(1, 7), ov::Dimension(1, 35), ov::Dimension(1, 35)}, - {{ 1, 5, 32, 32 }, { 2, 5, 32, 20 }, { 2, 5, 32, 32 }}}}, { 0, 2, 5, 4 }, { 1, 4, 28, 27 }, { 1, 1, 1, 1 }, { 0, 1, 2, 3 } }, - Slice8SpecificParams{ {{{ov::Dimension(1, 5), ov::Dimension(10, 20), ov::Dimension(20, 30), 16, ov::Dimension(30, 40)}, - {{ 4, 15, 30, 16, 39 }}}}, { 0, 2, 10, 0, 35 }, { 1, 8, 25, 16, 40 }, { 1, 1, 1, 1, 1 }, { 0, 1, 2, 3, 4 } } -}; - -INSTANTIATE_TEST_SUITE_P(smoke_Slice8Serialization_dynamic, Slice8LayerTest, - ::testing::Combine( - ::testing::ValuesIn(dynamicParams), - ::testing::ValuesIn(inputPrecisions), - ::testing::Values(ElementType::undefined), - ::testing::Values(ElementType::undefined), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU), - ::testing::Values(std::map())), - Slice8LayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/space_to_batch.cpp b/src/tests/functional/inference_engine/serialization/single_layer/space_to_batch.cpp deleted file mode 100644 index 004096cae5e..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/space_to_batch.cpp +++ /dev/null @@ -1,38 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/space_to_batch.hpp" - -#include - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(SpaceToBatchLayerTest, Serialize) { - Serialize(); -} - -const std::vector> blockShapes4D{{1, 1, 2, 2}}; -const std::vector> padsBegins4D{{0, 0, 0, 0}, - {0, 0, 0, 2}}; -const std::vector> padsEnds4D{{0, 0, 0, 0}, {0, 0, 0, 2}}; -const std::vector> dataShapes4D{ - {1, 1, 2, 2}, {1, 3, 2, 2}, {1, 1, 4, 4}, {2, 1, 2, 4}}; - -const auto SpaceToBatch4D = ::testing::Combine( - ::testing::ValuesIn(blockShapes4D), ::testing::ValuesIn(padsBegins4D), - ::testing::ValuesIn(padsEnds4D), ::testing::ValuesIn(dataShapes4D), - ::testing::Values(InferenceEngine::Precision::FP32), - ::testing::Values(InferenceEngine::Precision::FP32), - ::testing::Values(InferenceEngine::Precision::FP32), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P(smoke_spacetobatch4D_Serialization, - SpaceToBatchLayerTest, SpaceToBatch4D, - SpaceToBatchLayerTest::getTestCaseName); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/space_to_depth.cpp b/src/tests/functional/inference_engine/serialization/single_layer/space_to_depth.cpp deleted file mode 100644 index a970629c2a0..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/space_to_depth.cpp +++ /dev/null @@ -1,45 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "shared_test_classes/single_layer/space_to_depth.hpp" - -#include - -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; -using namespace ngraph::opset3; - -namespace { -TEST_P(SpaceToDepthLayerTest, Serialize) { - Serialize(); -} -const std::vector inputPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::U8, - InferenceEngine::Precision::I16, -}; - -const std::vector modes = { - SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, - SpaceToDepth::SpaceToDepthMode::DEPTH_FIRST}; - -const std::vector> inputShapesBS2 = { - {1, 1, 2, 2}, {1, 1, 4, 4}, {1, 1, 6, 6}, {2, 8, 6, 6}, - {2, 4, 10, 8}, {1, 1, 2, 2, 2}, {1, 1, 4, 4, 4}, {1, 1, 6, 6, 6}, - {2, 8, 6, 6, 6}, {2, 4, 10, 8, 12}}; - -const auto SpaceToDepthBS2 = ::testing::Combine( - ::testing::ValuesIn(inputShapesBS2), ::testing::ValuesIn(inputPrecisions), - ::testing::ValuesIn(modes), ::testing::Values(1, 2), - ::testing::Values(CommonTestUtils::DEVICE_CPU)); - -INSTANTIATE_TEST_SUITE_P( - smoke_SpaceToDepthSerialization, SpaceToDepthLayerTest, - ::testing::Combine(::testing::ValuesIn(inputShapesBS2), - ::testing::ValuesIn(inputPrecisions), - ::testing::ValuesIn(modes), ::testing::Values(1, 2), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - SpaceToDepthLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/split.cpp b/src/tests/functional/inference_engine/serialization/single_layer/split.cpp deleted file mode 100644 index 5869c51d9b0..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/split.cpp +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/split.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(SplitLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U16, - InferenceEngine::Precision::BOOL}; - -INSTANTIATE_TEST_SUITE_P( - smoke_Split_Serialization, SplitLayerTest, - ::testing::Combine( - ::testing::Values(1, 2, 5, 10), - ::testing::Values(0, 1, 2, 3), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector{20, 30, 50, 50}), - ::testing::Values(std::vector({})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - SplitLayerTest::getTestCaseName -); - -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/squeeze.cpp b/src/tests/functional/inference_engine/serialization/single_layer/squeeze.cpp deleted file mode 100644 index 2f22ca34280..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/squeeze.cpp +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/squeeze_unsqueeze.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(SqueezeUnsqueezeLayerTest, Serialize) { - Serialize(); -} - -std::map, std::vector>> axesVectors = { - {{1, 1, 1, 1}, {{}, {-1}, {0}, {1}, {2}, {3}, {0, 1}, {0, 2}, {0, 3}, {1, 2}, {2, 3}, {0, 1, 2}, {0, 2, 3}, {1, 2, 3}, {0, 1, 2, 3}}}, - {{1, 2, 3, 4}, {{}, {0}}}, - {{2, 1, 3, 4}, {{}, {1}}}, - {{1}, {{}, {-1}, {0}}}, - {{1, 2}, {{}, {0}}}, - {{2, 1}, {{}, {1}, {-1}}}, -}; - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U32}; - -const std::vector opTypes = { - ngraph::helpers::SqueezeOpType::SQUEEZE}; - -INSTANTIATE_TEST_SUITE_P(smoke_Squeeze_Basic, SqueezeUnsqueezeLayerTest, - ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(axesVectors)), - ::testing::ValuesIn(opTypes), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - SqueezeUnsqueezeLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/tensor_iterator.cpp b/src/tests/functional/inference_engine/serialization/single_layer/tensor_iterator.cpp deleted file mode 100644 index 5946fd03b60..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/tensor_iterator.cpp +++ /dev/null @@ -1,47 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "common_test_utils/test_constants.hpp" -#include "shared_test_classes/single_layer/tensor_iterator.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(TensorIteratorTest, Serialize_IR10) { - Serialize(ov::pass::Serialize::Version::IR_V10); -} - -TEST_P(TensorIteratorTest, Serialize_IR11) { - Serialize(ov::pass::Serialize::Version::IR_V11); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, InferenceEngine::Precision::FP16}; -const std::vector body = { - ngraph::helpers::TensorIteratorBody::GRU, ngraph::helpers::TensorIteratorBody::LSTM, ngraph::helpers::TensorIteratorBody::RNN}; -const std::vector decompose = {true, false}; -const std::vector sequenceLength = {2}; -const std::vector batch = {1, 10}; -const std::vector hiddenSize = {128}; -const std::vector sequenceAxis = {1}; -const std::vector clip = {0.f}; -const std::vector direction = { - ngraph::op::RecurrentSequenceDirection::FORWARD, ngraph::op::RecurrentSequenceDirection::REVERSE}; - -INSTANTIATE_TEST_SUITE_P(smoke_TensorIterator, TensorIteratorTest, - ::testing::Combine( - ::testing::ValuesIn(decompose), - ::testing::ValuesIn(sequenceLength), - ::testing::ValuesIn(batch), - ::testing::ValuesIn(hiddenSize), - ::testing::ValuesIn(sequenceAxis), - ::testing::ValuesIn(clip), - ::testing::ValuesIn(body), - ::testing::ValuesIn(direction), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - TensorIteratorTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/transpose.cpp b/src/tests/functional/inference_engine/serialization/single_layer/transpose.cpp deleted file mode 100644 index 376492daaa6..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/transpose.cpp +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/transpose.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - -TEST_P(TransposeLayerTest, Serialize) { - Serialize(); -} - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32 -}; - -std::vector> inputShape2D = {{2, 10}, {10, 2}, {10, 10}}; -std::vector> order2D = {{}, {0, 1}, {1, 0}}; - -INSTANTIATE_TEST_SUITE_P(smoke_Transpose2D, TransposeLayerTest, - ::testing::Combine( - ::testing::ValuesIn(order2D), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::ValuesIn(inputShape2D), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - TransposeLayerTest::getTestCaseName); - -std::vector> inputShape4D = {{2, 2, 2, 2}}; -std::vector> order4D = { - {}, {0, 1, 2, 3} -}; - -INSTANTIATE_TEST_SUITE_P(smoke_Transpose4D, TransposeLayerTest, - ::testing::Combine( - ::testing::ValuesIn(order4D), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::ValuesIn(inputShape4D), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - TransposeLayerTest::getTestCaseName); - -std::vector> inputShape5D = {{2, 3, 4, 5, 6}}; -std::vector> order5D = { - {}, {0, 1, 2, 3, 4} -}; - -INSTANTIATE_TEST_SUITE_P(smoke_Transpose5D, TransposeLayerTest, - ::testing::Combine( - ::testing::ValuesIn(order5D), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::ValuesIn(inputShape5D), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - TransposeLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/unsqueeze.cpp b/src/tests/functional/inference_engine/serialization/single_layer/unsqueeze.cpp deleted file mode 100644 index d4a547339aa..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/unsqueeze.cpp +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/squeeze_unsqueeze.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { -TEST_P(SqueezeUnsqueezeLayerTest, Serialize) { - Serialize(); -} - -std::map, std::vector>> axesVectors = { - {{1, 1, 1, 1}, {{-1}, {0}, {1}, {2}, {3}, {0, 1}, {0, 2}, {0, 3}, {1, 2}, {2, 3}, {0, 1, 2}, {0, 2, 3}, {1, 2, 3}, {0, 1, 2, 3}}}, - {{1, 2, 3, 4}, {{0}}}, - {{2, 1, 3, 4}, {{1}}}, - {{1}, {{-1}, {0}}}, - {{1, 2}, {{0}}}, - {{2, 1}, {{1}, {-1}}}, -}; - -const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16, - InferenceEngine::Precision::I32, - InferenceEngine::Precision::U32}; - -const std::vector opTypes = { - ngraph::helpers::SqueezeOpType::UNSQUEEZE}; - -INSTANTIATE_TEST_SUITE_P(smoke_Squeeze_Basic, SqueezeUnsqueezeLayerTest, - ::testing::Combine( - ::testing::ValuesIn(CommonTestUtils::combineParams(axesVectors)), - ::testing::ValuesIn(opTypes), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - SqueezeUnsqueezeLayerTest::getTestCaseName); -} // namespace diff --git a/src/tests/functional/inference_engine/serialization/single_layer/variadic_split.cpp b/src/tests/functional/inference_engine/serialization/single_layer/variadic_split.cpp deleted file mode 100644 index 2bf14c75529..00000000000 --- a/src/tests/functional/inference_engine/serialization/single_layer/variadic_split.cpp +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright (C) 2018-2022 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include - -#include "shared_test_classes/single_layer/variadic_split.hpp" -#include "common_test_utils/test_constants.hpp" - -using namespace LayerTestsDefinitions; - -namespace { - TEST_P(VariadicSplitLayerTest, Serialize) { - Serialize(); - } - - const std::vector netPrecisions = { - InferenceEngine::Precision::FP32, - InferenceEngine::Precision::FP16 - }; - - // Sum of elements numSplits = inputShapes[Axis] - const std::vector> numSplits = { - {1, 16, 5, 8}, - }; - - INSTANTIATE_TEST_SUITE_P(smoke_VariadicSplitSerialization, VariadicSplitLayerTest, - ::testing::Combine( - ::testing::ValuesIn(numSplits), - ::testing::Values(0, 1, 2, 3), - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({30, 30, 30, 30})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - VariadicSplitLayerTest::getTestCaseName); -} // namespace