From d18d8a457f5d86e2c26314f11d4e2cfa39de015b Mon Sep 17 00:00:00 2001 From: Oleg Pipikin Date: Wed, 13 Dec 2023 15:21:23 +0100 Subject: [PATCH] Update create_and_fill_tensor to work with InputGenerateData (#20008) * Update create_and_fill_tensor to work with InputGenerateData --- .../single_layer_tests/adaptive_pooling.cpp | 10 +- .../single_layer_tests/batch_to_space.cpp | 6 +- .../single_layer_tests/broadcast.cpp | 10 +- .../single_layer_tests/bucketize.cpp | 13 +- .../single_layer_tests/classes/activation.cpp | 7 +- .../single_layer_tests/classes/conversion.cpp | 6 +- .../single_layer_tests/classes/eltwise.cpp | 6 +- .../single_layer_tests/classes/reduce.cpp | 10 +- .../convolution_backprop_data.cpp | 10 +- .../single_layer_tests/ctc_greedy_decoder.cpp | 13 +- .../ctc_greedy_decoder_seq_len.cpp | 21 ++- .../single_layer_tests/ctc_loss.cpp | 6 +- .../deformable_convolution.cpp | 39 ++++-- .../functional/single_layer_tests/eye.cpp | 9 +- .../single_layer_tests/fake_quantize.cpp | 8 +- .../functional/single_layer_tests/gather.cpp | 22 ++-- .../single_layer_tests/gather_elements.cpp | 11 +- .../single_layer_tests/gather_tree.cpp | 8 +- .../single_layer_tests/grid_sample.cpp | 24 ++-- .../group_convolution_backprop_data.cpp | 11 +- .../single_layer_tests/interpolate.cpp | 6 +- .../functional/single_layer_tests/loop.cpp | 19 ++- .../functional/single_layer_tests/nonzero.cpp | 5 +- .../single_layer_tests/normalize.cpp | 8 +- .../functional/single_layer_tests/pad.cpp | 5 +- .../single_layer_tests/proposal.cpp | 6 +- .../single_layer_tests/reverse_sequence.cpp | 7 +- .../single_layer_tests/roi_pooling.cpp | 6 +- .../single_layer_tests/roialign.cpp | 6 +- .../single_layer_tests/scatter_ND_update.cpp | 6 +- .../scatter_elements_update.cpp | 6 +- .../functional/single_layer_tests/select.cpp | 30 ++--- .../single_layer_tests/shape_ops.cpp | 18 +-- .../functional/single_layer_tests/slice.cpp | 14 +- .../single_layer_tests/space_to_batch.cpp | 10 +- .../single_layer_tests/strided_slice.cpp | 10 +- .../functional/single_layer_tests/tile.cpp | 10 +- .../functional/single_layer_tests/topk.cpp | 9 +- .../functional/single_layer_tests/unique.cpp | 14 +- .../src/convert_fq_rnn_to_quantized_rnn.cpp | 14 +- .../subgraph_tests/src/eltwise_caching.cpp | 5 +- .../subgraph_tests/src/eltwise_chain.cpp | 5 +- .../subgraph_tests/src/fq_caching.cpp | 8 +- .../subgraph_tests/src/interaction.cpp | 10 +- .../functional/subgraph_tests/src/mha.cpp | 40 +++--- .../functional/subgraph_tests/src/ngram.cpp | 5 +- .../subgraph_tests/src/reshape_inplace.cpp | 10 +- .../subgraph_tests/src/rotary_pos_emb.cpp | 7 +- .../gpu_remote_tensor_tests.cpp | 71 +++++++--- .../single_layer_tests/dynamic/broadcast.cpp | 7 +- .../dynamic/convolution_backprop_data.cpp | 6 +- .../dynamic/detection_output.cpp | 6 +- .../dynamic/gather_elements.cpp | 6 +- .../dynamic/gather_tree.cpp | 8 +- .../dynamic/grid_sample.cpp | 13 +- .../group_convolution_backprop_data.cpp | 6 +- .../dynamic/interpolate.cpp | 6 +- .../single_layer_tests/dynamic/pad.cpp | 7 +- .../dynamic/roi_pooling.cpp | 6 +- .../dynamic/scatter_nd_update.cpp | 6 +- .../single_layer_tests/dynamic/tile.cpp | 7 +- .../single_layer_tests/dynamic/top_k.cpp | 9 +- .../single_layer_tests/dynamic/unique.cpp | 9 +- .../functional/subgraph_tests/condition.cpp | 7 +- .../dynamic_model_static_split_layer.cpp | 26 ++-- .../dynamic_smoke_test_gen_impl_key.cpp | 24 ++-- ...smoke_test_reduce_deconvolution_concat.cpp | 24 ++-- ...dynamic_smoke_test_shape_of_activation.cpp | 26 ++-- ...mic_smoke_test_shape_of_reduce_reshape.cpp | 24 ++-- .../dynamic_smoke_test_with_empty_tensor.cpp | 40 +++--- .../dynamic/matmul_weights_decompression.cpp | 14 +- .../src/read_ir/read_ir.cpp | 4 +- .../infer_request_dynamic.cpp | 28 +++- .../plugin/shared/src/snippets/convert.cpp | 7 +- .../plugin/shared/src/snippets/mha.cpp | 20 ++- .../plugin/shared/src/snippets/select.cpp | 18 ++- .../base/utils/generate_inputs.hpp | 3 + .../shared_test_classes/base/utils/ranges.hpp | 73 +++-------- .../src/base/utils/generate_inputs.cpp | 121 +++++++++++++----- .../src/single_layer/gather_elements.cpp | 5 +- .../src/single_op/batch_norm.cpp | 13 +- .../src/single_op/eltwise.cpp | 13 +- .../src/single_op/gather.cpp | 10 +- .../src/single_op/gather_elements.cpp | 5 +- .../src/single_op/gather_tree.cpp | 5 +- .../src/single_op/gru_sequence.cpp | 5 +- .../src/single_op/lstm_sequence.cpp | 5 +- .../src/single_op/multiclass_nms.cpp | 3 +- .../src/single_op/rnn_sequence.cpp | 5 +- .../src/subgraph/simple_if.cpp | 8 +- .../common_test_utils/ov_tensor_utils.hpp | 21 ++- .../src/node_builders/augru_cell.cpp | 8 +- .../src/node_builders/gru_cell.cpp | 8 +- .../src/node_builders/lstm_cell.cpp | 22 ++-- .../src/node_builders/rnn_cell.cpp | 8 +- .../common_test_utils/src/ov_tensor_utils.cpp | 72 ++++++----- .../src/postgres_helpers.cpp | 2 +- .../common_test_utils/src/postgres_link.cpp | 8 +- 98 files changed, 862 insertions(+), 545 deletions(-) diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/adaptive_pooling.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/adaptive_pooling.cpp index 6b0a97a84a5..d7df67e2eb9 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/adaptive_pooling.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/adaptive_pooling.cpp @@ -159,11 +159,11 @@ protected: dataPtr[i] = pooledVector[i]; } } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 2560, - 0, - 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/batch_to_space.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/batch_to_space.cpp index 39eb90391a8..789d45d589f 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/batch_to_space.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/batch_to_space.cpp @@ -66,7 +66,11 @@ public: const auto& static_shape = targetInputStaticShapes[i]; switch (i) { case 0: { - tensor = ov::test::utils::create_and_fill_tensor(param_type, static_shape, 2560, 0, 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(param_type, static_shape, in_data); break; } case 1: { diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/broadcast.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/broadcast.cpp index 62df3e54608..30837593410 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/broadcast.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/broadcast.cpp @@ -171,11 +171,11 @@ protected: } } else { if (funcInput.get_element_type().is_real()) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - 0, - 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/bucketize.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/bucketize.cpp index 2e2cf824bd5..9f9a99d6fef 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/bucketize.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/bucketize.cpp @@ -58,13 +58,12 @@ public: const auto& funcInputs = function->inputs(); auto data_size = shape_size(targetInputStaticShapes[0]); - ov::Tensor tensorData = ov::test::utils::create_and_fill_tensor(funcInputs[0].get_element_type(), - targetInputStaticShapes[0], - data_size * 5, - 0, - 10, - 7235346); - + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = data_size * 5; + in_data.resolution = 10; + in_data.seed = 7235346; + ov::Tensor tensorData = ov::test::utils::create_and_fill_tensor(funcInputs[0].get_element_type(), targetInputStaticShapes[0], in_data); ov::Tensor tensorBucket = ov::test::utils::create_and_fill_tensor_unique_sequence(funcInputs[1].get_element_type(), targetInputStaticShapes[1], diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/activation.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/activation.cpp index 587547fcb73..5eafb558b05 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/activation.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/activation.cpp @@ -78,8 +78,11 @@ void ActivationLayerCPUTest::generate_inputs(const std::vector& targe const auto& funcInput = funcInputs[i]; ov::Tensor tensor; if (funcInput.get_element_type().is_real()) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], - range, startFrom, resolution); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = startFrom; + in_data.range = range; + in_data.resolution = resolution; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/conversion.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/conversion.cpp index 39bc1917dee..2e0e0d603fd 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/conversion.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/conversion.cpp @@ -98,7 +98,11 @@ void ConvertCPULayerTest::generate_inputs(const std::vector& targetIn auto shape = targetInputStaticShapes.front(); size_t size = shape_size(shape); - ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInputs[0].get_element_type(), shape, 2 * size); + + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2 * size; + ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInputs[0].get_element_type(), shape, in_data); if (inPrc == ov::element::f32) { auto* rawBlobDataPtr = static_cast(tensor.data()); diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/eltwise.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/eltwise.cpp index 83d518bafa9..f57d10b171a 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/eltwise.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/eltwise.cpp @@ -85,7 +85,11 @@ ov::Tensor EltwiseLayerCPUTest::generate_eltwise_input(const ov::element::Type& break; } } - return ov::test::utils::create_and_fill_tensor(type, shape, params.range, params.start_from, params.resolution); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = params.start_from; + in_data.range = params.range; + in_data.resolution = params.resolution; + return ov::test::utils::create_and_fill_tensor(type, shape, in_data); } void EltwiseLayerCPUTest::generate_inputs(const std::vector& targetInputStaticShapes) { diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/reduce.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/reduce.cpp index a6522ce2212..20e32f5c9fd 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/reduce.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/classes/reduce.cpp @@ -145,11 +145,11 @@ void ReduceCPULayerTest::generate_inputs(const std::vector& targetInp for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - if (reductionType == utils::ReductionType::Prod) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - 5); + if (reductionType == ngraph::helpers::ReductionType::Prod) { + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 5; + in_data.range = 10; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); if (netPrecision == ElementType::f32) { auto* rawBlobDataPtr = static_cast(tensor.data()); for (size_t i = 0; i < tensor.get_size(); ++i) { diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/convolution_backprop_data.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/convolution_backprop_data.cpp index 073226657dd..b1737e65469 100755 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/convolution_backprop_data.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/convolution_backprop_data.cpp @@ -109,11 +109,11 @@ public: targetInputStaticShapes[i], outShapeData[inferRequestNum].data()); } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 2560, - 0, - 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder.cpp index c75d192c1e9..bbb4c9b05ac 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder.cpp @@ -92,14 +92,13 @@ protected: ov::Tensor tensor; if (i == 0) { if (funcInput.get_element_type().is_real()) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - 0, - 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i]); + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } } else { auto T = targetInputStaticShapes[i][0]; diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder_seq_len.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder_seq_len.cpp index 96e6d7fea65..22ec4c1a97f 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder_seq_len.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_greedy_decoder_seq_len.cpp @@ -116,14 +116,13 @@ protected: ov::Tensor tensor; if (i == 0) { if (funcInput.get_element_type().is_real()) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - 0, - 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i]); + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } } else if (i == 1) { const auto seqLen = dataShape[1]; @@ -147,10 +146,10 @@ protected: } else if (i == 2) { // blank should be valid class type - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - dataShape[2], - 0); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = dataShape[2]; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_loss.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_loss.cpp index 014c2388fef..9404fdce874 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_loss.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/ctc_loss.cpp @@ -134,7 +134,11 @@ protected: const auto& funcInput = funcInputs[i]; ov::Tensor tensor; if (i == 0) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), dataShape, 10, 0, 10); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 10; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), dataShape, in_data); } else if (i == 1) { tensor = ov::Tensor{funcInput.get_element_type(), {shapeN}}; if (funcInput.get_element_type() == ElementType::i32) { diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/deformable_convolution.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/deformable_convolution.cpp index 73b269b4356..d3e30ce2861 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/deformable_convolution.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/deformable_convolution.cpp @@ -101,29 +101,48 @@ protected: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::Tensor tensor; + ov::test::utils::InputGenerateData in_data; if (i == 0) { // "a_data" - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), inShape, 2, -1, 100); + in_data.start_from = -1; + in_data.range = 2; + in_data.resolution = 100; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), inShape, in_data); } else if (i == 1) { // "b_offset_vals" if (offsetType == OffsetType::NATURAL) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 10, 0, 1); + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1; } else if (offsetType == OffsetType::ZERO) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 1, 0, 1); + in_data.start_from = 0; + in_data.range = 1; + in_data.resolution = 1; } else if (offsetType == OffsetType::REAL_POSITIVE) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 2, 0, 100); + in_data.start_from = 0; + in_data.range = 2; + in_data.resolution = 100; } else if (offsetType == OffsetType::REAL_NEGATIVE) { - tensor = - ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 2, -2, 100); + in_data.start_from = -2; + in_data.range = 2; + in_data.resolution = 100; } else if (offsetType == OffsetType::REAL_MISC) { - tensor = - ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, 4, -2, 100); + in_data.start_from = -2; + in_data.range = 4; + in_data.resolution = 100; } else { OPENVINO_THROW("Unexpected offset type"); } + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), offShape, in_data); } else if (i == 2) { // "c_filter_vals" - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), filtShape, 2, -1, 100); + in_data.start_from = -1; + in_data.range = 2; + in_data.resolution = 100; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), filtShape, in_data); } else if (i == 3) { // "c_modulation_scalars" auto modShape = targetInputStaticShapes[3]; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), modShape, 1, 0, 100); + in_data.start_from = -1; + in_data.range = 2; + in_data.resolution = 100; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), modShape, in_data); } else { OPENVINO_THROW("Unknown input of DeformableConvolution"); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/eye.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/eye.cpp index 5dc2219e382..053261035ce 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/eye.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/eye.cpp @@ -120,10 +120,11 @@ protected: batchShapePtr[j] = outBatchShape[j]; } } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 1, - (i == 0 ? rowNum : (i == 1 ? colNum : shift))); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = i == 0 ? rowNum : (i == 1 ? colNum : 6); + in_data.range = 1; + + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/fake_quantize.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/fake_quantize.cpp index 760f2bcaed1..007f4cf4314 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/fake_quantize.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/fake_quantize.cpp @@ -131,10 +131,10 @@ protected: ASSERT_EQ(funcInputs.size(), 1); const auto& funcInput = funcInputs[0]; ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[0], - inDataHighBounds - inDataLowBounds, - inDataLowBounds); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = inDataLowBounds; + in_data.range = inDataHighBounds - inDataLowBounds; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather.cpp index 214947c2549..6d9ac97310f 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather.cpp @@ -129,23 +129,21 @@ protected: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::runtime::Tensor tensor; + ov::test::utils::InputGenerateData in_data; if (funcInput.get_node()->get_friendly_name() == "data") { const auto dataTypeSize = funcInput.get_element_type().size(); - const uint32_t range = dataTypeSize == 4 ? 0x7FFFFFFF : dataTypeSize == 2 ? 0xFFFF : 0xFF; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[0], - range, - 0, - 1); + in_data.start_from = 0; + in_data.range = dataTypeSize == 4 ? 0x7FFFFFFF : dataTypeSize == 2 ? 0xFFFF : 0xFF; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data); } else if (funcInput.get_node()->get_friendly_name() == "indices") { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[1], - axisDim * 2, - -axisDim, - 1); + in_data.start_from = -axisDim; + in_data.range = axisDim * 2; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[1], in_data); } else if (funcInput.get_node()->get_friendly_name() == "axis") { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), {1}, 1, axis, 1); + in_data.start_from = axis; + in_data.range = 1; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), {1}, in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_elements.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_elements.cpp index 428a22f4051..e1cc152ffbc 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_elements.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_elements.cpp @@ -68,12 +68,11 @@ public: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 15, - 0, - 32768); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 15; + in_data.resolution = 32768; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_tree.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_tree.cpp index 2fd23207b01..055434c6477 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_tree.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/gather_tree.cpp @@ -118,10 +118,10 @@ protected: const auto& funcInputs = function->inputs(); for (size_t i = 0; i < funcInputs.size(); ++i) { - auto tensor = ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(), - targetInputStaticShapes[i], - maxBeamIndex, - (i == 2 || i == 3) ? maxBeamIndex / 2 : 0); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = (i == 2 || i == 3) ? maxBeamIndex / 2 : 0; + in_data.range = maxBeamIndex; + auto tensor = ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInputs[i].get_node_shared_ptr(), tensor}); } } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/grid_sample.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/grid_sample.cpp index bdc1f88bec1..3ef7ef621e0 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/grid_sample.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/grid_sample.cpp @@ -137,25 +137,19 @@ protected: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::runtime::Tensor tensor; + ov::test::utils::InputGenerateData in_data; if (funcInput.get_node()->get_friendly_name() == "data") { - int32_t range = std::accumulate(targetInputStaticShapes[0].begin(), - targetInputStaticShapes[0].end(), - 1u, - std::multiplies()); - tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[0], - range, - -range / 2, - 1); + int32_t range = std::accumulate(targetInputStaticShapes[0].begin(), targetInputStaticShapes[0].end(), 1u, std::multiplies()); + in_data.start_from = -range / 2; + in_data.range = range; + tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data); } else if (funcInput.get_node()->get_friendly_name() == "grid") { int32_t range = std::max(targetInputStaticShapes[0][2], targetInputStaticShapes[0][3]) + 2; - int32_t resolution = range / 2; - tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[1], - range, - -1, - resolution == 0 ? 1 : resolution); + in_data.start_from = -1; + in_data.range = range; + in_data.resolution = range / 2; + tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[1], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/group_convolution_backprop_data.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/group_convolution_backprop_data.cpp index d72eaf2576d..1279f81aacd 100755 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/group_convolution_backprop_data.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/group_convolution_backprop_data.cpp @@ -110,11 +110,12 @@ public: targetInputStaticShapes[i], outShapeData[inferRequestNum].data()); } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 2560, - 0, - 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/interpolate.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/interpolate.cpp index 1105165476f..123cf64e397 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/interpolate.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/interpolate.cpp @@ -120,7 +120,11 @@ public: tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], scales[inferRequestNum].data()); } } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/loop.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/loop.cpp index 88492cbe5f9..5073d8f9662 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/loop.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/loop.cpp @@ -66,8 +66,10 @@ protected: size_t i = 0; if (funcInputs[i].get_node_shared_ptr()->get_friendly_name() == "trip_count") { const auto& funcInput = funcInputs[i]; - ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - funcInput.get_shape(), 10, 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = 10; + ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), funcInput.get_shape(), in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); i++; } @@ -75,8 +77,11 @@ protected: // parameters for body for (; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; - ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], 15, 0, 32768); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 15; + in_data.resolution = 32768; + ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } } @@ -425,7 +430,11 @@ class StaticLoopDynamicSubgraphCPUTest : public SubgraphBaseTest { auto* dataPtr = tensor.data(); *dataPtr = true; } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/nonzero.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/nonzero.cpp index 6a52efb79f0..b3b47e3d12c 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/nonzero.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/nonzero.cpp @@ -55,7 +55,10 @@ public: const auto& funcInputs = function->inputs(); for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; - ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], range, startFrom); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = startFrom; + in_data.range = range; + ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/normalize.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/normalize.cpp index 6593dd0c759..9c82f0bdf93 100755 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/normalize.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/normalize.cpp @@ -90,8 +90,12 @@ protected: const auto& funcInput = funcInputs[i]; ov::Tensor tensor; if (funcInput.get_element_type().is_real()) { - tensor = ov::test::utils::create_and_fill_tensor( - funcInput.get_element_type(), targetInputStaticShapes[i], 10, -5, 7, 222); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -5; + in_data.range = 10; + in_data.resolution = 7; + in_data.seed = 222; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/pad.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/pad.cpp index a6c06628262..c5124d9cb95 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/pad.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/pad.cpp @@ -67,7 +67,10 @@ protected: const auto& funcInput = funcInputs[i]; ov::Tensor tensor; if (i == 0) { - tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 1, 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = 10; + tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { if (funcInput.get_node()->get_friendly_name() == "pad_value") tensor = ov::Tensor{funcInput.get_element_type(), ov::Shape{}, &padValue}; diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/proposal.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/proposal.cpp index 2e08c459cf0..6f6c1c270d7 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/proposal.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/proposal.cpp @@ -180,7 +180,11 @@ protected: dataPtr[2] = 1.0f; if (tensor.get_size() == 4) dataPtr[3] = 1.0f; } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/reverse_sequence.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/reverse_sequence.cpp index b23d0fba525..e440d7496fe 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/reverse_sequence.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/reverse_sequence.cpp @@ -99,10 +99,11 @@ protected: if (funcInputs.size() != 1) { const auto maxSeqLength = targetInputStaticShapes.front().at(m_seqAxisIndex); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = maxSeqLength; const auto seqLengthsTensor = - ov::test::utils::create_and_fill_tensor(funcInputs[1].get_element_type(), - targetInputStaticShapes[1], - maxSeqLength, 1); + ov::test::utils::create_and_fill_tensor(funcInputs[1].get_element_type(), targetInputStaticShapes[1], in_data); inputs.insert({funcInputs[1].get_node_shared_ptr(), seqLengthsTensor}); } } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/roi_pooling.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/roi_pooling.cpp index b8da94cf082..fe8a8ff49a1 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/roi_pooling.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/roi_pooling.cpp @@ -161,7 +161,11 @@ protected: } } } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({ funcInput.get_node_shared_ptr(), tensor }); diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/roialign.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/roialign.cpp index 4798df6aea5..475607a743f 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/roialign.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/roialign.cpp @@ -85,7 +85,11 @@ protected: ov::Tensor data_tensor; const auto& dataPrecision = funcInputs[0].get_element_type(); const auto& dataShape = targetInputStaticShapes.front(); - data_tensor = ov::test::utils::create_and_fill_tensor(dataPrecision, dataShape, 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + data_tensor = ov::test::utils::create_and_fill_tensor(dataPrecision, dataShape, in_data); const auto& coordsET = funcInputs[1].get_element_type(); auto coordsTensor = ov::Tensor{ coordsET, targetInputStaticShapes[1] }; diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_ND_update.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_ND_update.cpp index 54866ac5762..33dce880d9c 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_ND_update.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_ND_update.cpp @@ -77,7 +77,11 @@ protected: } } else { if (inputPrecision.is_real()) { - tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape, 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape, ov::test::utils::InputGenerateData(0, 10, 1000)); } else { tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_elements_update.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_elements_update.cpp index 08828a4c0be..9d384723f6e 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_elements_update.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/scatter_elements_update.cpp @@ -80,7 +80,11 @@ protected: } } else { if (inputPrecision.is_real()) { - tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape, 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape, in_data); } else { tensor = ov::test::utils::create_and_fill_tensor(inputPrecision, targetShape); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/select.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/select.cpp index f66768c314c..0bda4980534 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/select.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/select.cpp @@ -71,21 +71,21 @@ protected: void generate_inputs(const std::vector& targetInputStaticShapes) override { inputs.clear(); const auto& modelInputs = function->inputs(); - auto condTensor = ov::test::utils::create_and_fill_tensor(modelInputs[0].get_element_type(), - targetInputStaticShapes[0], - 3, - -1, - 2); - auto thenTensor = ov::test::utils::create_and_fill_tensor(modelInputs[1].get_element_type(), - targetInputStaticShapes[1], - 10, - -10, - 2); - auto elseTensor = ov::test::utils::create_and_fill_tensor(modelInputs[2].get_element_type(), - targetInputStaticShapes[2], - 10, - 0, - 2); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -1; + in_data.range = 3; + in_data.resolution = 2; + auto condTensor = ov::test::utils::create_and_fill_tensor(modelInputs[0].get_element_type(), targetInputStaticShapes[0], in_data); + + in_data.start_from = -10; + in_data.range = 10; + in_data.resolution = 2; + auto thenTensor = ov::test::utils::create_and_fill_tensor(modelInputs[1].get_element_type(), targetInputStaticShapes[1], in_data); + + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 2; + auto elseTensor = ov::test::utils::create_and_fill_tensor(modelInputs[2].get_element_type(), targetInputStaticShapes[2], in_data); inputs.insert({modelInputs[0].get_node_shared_ptr(), condTensor}); inputs.insert({modelInputs[1].get_node_shared_ptr(), thenTensor}); inputs.insert({modelInputs[2].get_node_shared_ptr(), elseTensor}); diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/shape_ops.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/shape_ops.cpp index 196281d1572..6b195a7086e 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/shape_ops.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/shape_ops.cpp @@ -103,20 +103,20 @@ protected: #undef RESHAPE_TEST_CASE } } else { + ov::test::utils::InputGenerateData in_data; if (isWithNonZero) { // fill tensor with all zero, so the NonZero op will create 0 shape as the input of reshape op - tensor = - utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 1, 0); + in_data.start_from = 0; + in_data.range = 1; + tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { if (funcInput.get_element_type().is_real()) { - tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - 0, - 1000); + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { - tensor = - utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); + tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } } } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/slice.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/slice.cpp index 45b68a6c837..3629c5b28c2 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/slice.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/slice.cpp @@ -71,16 +71,16 @@ protected: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - if (i == 0u) + if (i == 0u) { + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = 10; // Fill the slice input0 tensor with random data. - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - 1, - 1); - else + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); + } else { // Fill the slice input1~input4 with specified data. tensor = ov::Tensor{ov::element::i64, targetInputStaticShapes[i], inputValues[i - 1]}; + } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/space_to_batch.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/space_to_batch.cpp index 710302cba87..2fa66d0c124 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/space_to_batch.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/space_to_batch.cpp @@ -63,11 +63,11 @@ public: const auto& funcInput = funcInputs[i]; ov::Tensor tensor; if (i == 0U) { - tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 2560, - 0, - 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else if (i == 1U) { tensor = ov::Tensor(funcInput.get_element_type(), paramShape); auto* dataPtr = tensor.data(); diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/strided_slice.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/strided_slice.cpp index 58abdabb2c5..f76100141cb 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/strided_slice.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/strided_slice.cpp @@ -76,11 +76,11 @@ protected: const auto& funcInput = funcInputs[i]; ov::Tensor tensor; if (i == 0) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - 1, - 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = 10; + in_data.resolution = 1; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { tensor = ov::Tensor{ov::element::i64, targetInputStaticShapes[i], inputValues[i - 1]}; } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/tile.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/tile.cpp index ea79bd63385..0586c655150 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/tile.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/tile.cpp @@ -121,11 +121,11 @@ protected: } } else { if (funcInput.get_element_type().is_real()) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - 0, - 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/topk.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/topk.cpp index afd63882920..4b6b05a293c 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/topk.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/topk.cpp @@ -215,10 +215,11 @@ private: const auto& kPrecision = funcInputs[1].get_element_type(); const auto& kShape = targetInputStaticShapes[1]; - const size_t startFrom = 1; - const size_t range = targetInputStaticShapes[0][axis]; - const size_t seed = inferRequestNum++; - const auto kTensor = ov::test::utils::create_and_fill_tensor(kPrecision, kShape, range, startFrom, 1, seed); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = targetInputStaticShapes[0][axis]; + in_data.seed = inferRequestNum++;; + const auto kTensor = ov::test::utils::create_and_fill_tensor(kPrecision, kShape, in_data); inputs.insert({funcInputs[1].get_node_shared_ptr(), kTensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/single_layer_tests/unique.cpp b/src/plugins/intel_cpu/tests/functional/single_layer_tests/unique.cpp index 5b03f057394..9ad0401f789 100644 --- a/src/plugins/intel_cpu/tests/functional/single_layer_tests/unique.cpp +++ b/src/plugins/intel_cpu/tests/functional/single_layer_tests/unique.cpp @@ -123,15 +123,11 @@ protected: ov::runtime::Tensor tensor; if (funcInput.get_node()->get_friendly_name() == "data") { - int32_t range = std::accumulate(targetInputStaticShapes[0].begin(), - targetInputStaticShapes[0].end(), - 1, - std::multiplies()); - tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[0], - range, - -range / 2, - 1); + int32_t range = std::accumulate(targetInputStaticShapes[0].begin(), targetInputStaticShapes[0].end(), 1, std::multiplies()); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -range / 2; + in_data.range = range; + tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/convert_fq_rnn_to_quantized_rnn.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/convert_fq_rnn_to_quantized_rnn.cpp index ff464d1774d..02eb3d6409e 100644 --- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/convert_fq_rnn_to_quantized_rnn.cpp +++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/convert_fq_rnn_to_quantized_rnn.cpp @@ -69,15 +69,23 @@ protected: const auto& shapeX = targetInputStaticShapes[0]; const auto& shapeH = targetInputStaticShapes[1]; - ov::Tensor tensorX = utils::create_and_fill_tensor(funcInputs[0].get_element_type(), shapeX, 1, 0, 16); - ov::Tensor tensorH = utils::create_and_fill_tensor(funcInputs[1].get_element_type(), shapeH, 1, 0, 16); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 1; + in_data.resolution = 16; + ov::Tensor tensorX = utils::create_and_fill_tensor(funcInputs[0].get_element_type(), shapeX, in_data); + ov::Tensor tensorH = utils::create_and_fill_tensor(funcInputs[1].get_element_type(), shapeH, in_data); inputs.insert({funcInputs[0].get_node_shared_ptr(), tensorX}); inputs.insert({funcInputs[1].get_node_shared_ptr(), tensorH}); if (hasCell) { const auto& shapeC = targetInputStaticShapes[cellIdx]; - ov::Tensor tensorC = utils::create_and_fill_tensor(funcInputs[cellIdx].get_element_type(), shapeC, 2, -1, 128, 2); + in_data.start_from = -1; + in_data.range = 2; + in_data.resolution = 128; + in_data.seed = 2; + ov::Tensor tensorC = utils::create_and_fill_tensor(funcInputs[cellIdx].get_element_type(), shapeC, in_data); inputs.insert({funcInputs[cellIdx].get_node_shared_ptr(), tensorC}); } } diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_caching.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_caching.cpp index 487235fa8dd..9ea9bc8e266 100644 --- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_caching.cpp +++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_caching.cpp @@ -128,7 +128,10 @@ public: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 1, 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = 10; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } } diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_chain.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_chain.cpp index cb8347051d6..8b3b48200ec 100644 --- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_chain.cpp +++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/eltwise_chain.cpp @@ -71,7 +71,10 @@ public: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 1, 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = 10; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } } diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fq_caching.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fq_caching.cpp index de83cda570e..d8940dc4dfa 100644 --- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fq_caching.cpp +++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/fq_caching.cpp @@ -206,10 +206,10 @@ protected: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - inDataHighBounds - inDataLowBounds, - inDataLowBounds); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = inDataLowBounds; + in_data.range = inDataHighBounds - inDataLowBounds; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } } diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/interaction.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/interaction.cpp index 572c4e80706..a23fb6953a2 100644 --- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/interaction.cpp +++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/interaction.cpp @@ -134,11 +134,11 @@ public: const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 15, - 0, - 32768); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 15; + in_data.resolution = 32768; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/mha.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/mha.cpp index dd117e2cd6a..1078ba85698 100644 --- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/mha.cpp +++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/mha.cpp @@ -189,17 +189,15 @@ public: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - if (funcInput.get_element_type() == ov::element::bf16) - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 2, - -1, - 256); - else - tensor = ov::test::utils::create_and_fill_tensor_unique_sequence(funcInput.get_element_type(), - targetInputStaticShapes[i], - -1, - 5); + if (funcInput.get_element_type() == ov::element::bf16) { + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -1; + in_data.range = 2; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); + } else { + tensor = ov::test::utils::create_and_fill_tensor_unique_sequence(funcInput.get_element_type(), targetInputStaticShapes[i], -1, 5); + } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } @@ -576,17 +574,15 @@ public: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - if (funcInput.get_element_type().is_real()) - tensor = ov::test::utils::create_and_fill_tensor_normal_distribution(funcInput.get_element_type(), - targetInputStaticShapes[i], - 0.0f, - 1.5f); - else - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 255, - 0, - 1); + if (funcInput.get_element_type().is_real()) { + tensor = ov::test::utils::create_and_fill_tensor_normal_distribution(funcInput.get_element_type(), targetInputStaticShapes[i], 0.0f, 1.5f); + } else { + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 255; + in_data.resolution = 1; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); + } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/ngram.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/ngram.cpp index 1634d2a62a4..25e7703c92f 100644 --- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/ngram.cpp +++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/ngram.cpp @@ -177,7 +177,10 @@ public: const auto& indices_et = model_inputs[1].get_element_type(); const auto& indices_shape = targetInputStaticShapes[1]; const size_t batch_size = data_shape[0]; - auto indices_tensor = ov::test::utils::create_and_fill_tensor(indices_et, indices_shape, batch_size, 0); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = batch_size; + auto indices_tensor = ov::test::utils::create_and_fill_tensor(indices_et, indices_shape, in_data); if (indices_et == ov::element::i32) { auto* indices_data = indices_tensor.data(); diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/reshape_inplace.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/reshape_inplace.cpp index 52caa4fdabc..ad97f392b00 100644 --- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/reshape_inplace.cpp +++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/reshape_inplace.cpp @@ -64,11 +64,11 @@ protected: } } else { if (funcInput.get_element_type().is_real()) { - tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - 0, - 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { tensor = utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/rotary_pos_emb.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/rotary_pos_emb.cpp index fa0262fe149..32e253875c9 100644 --- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/rotary_pos_emb.cpp +++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/rotary_pos_emb.cpp @@ -149,8 +149,11 @@ public: auto& input_shape = targetInputStaticShapes[0]; auto seq_length = input_shape[1]; - ov::Tensor t_input = - utils::create_and_fill_tensor(funcInputs[0].get_element_type(), input_shape, 2, -1.0f, 32768); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -1; + in_data.range = 2; + in_data.resolution = 32768; + ov::Tensor t_input = utils::create_and_fill_tensor(funcInputs[0].get_element_type(), input_shape, in_data); ov::Tensor t_position_id_end = create_i32_tensor(ov::Shape({}), position_id_start + seq_length); ov::Tensor t_position_ids = create_i32_tensor(ov::Shape({1, seq_length}), position_id_start); diff --git a/src/plugins/intel_gpu/tests/functional/remote_tensor_tests/gpu_remote_tensor_tests.cpp b/src/plugins/intel_gpu/tests/functional/remote_tensor_tests/gpu_remote_tensor_tests.cpp index ee83114ac07..4e6a60ca4ab 100644 --- a/src/plugins/intel_gpu/tests/functional/remote_tensor_tests/gpu_remote_tensor_tests.cpp +++ b/src/plugins/intel_gpu/tests/functional/remote_tensor_tests/gpu_remote_tensor_tests.cpp @@ -1262,7 +1262,10 @@ TEST_F(OVRemoteTensor_Test, NV12toGray) { // ------------------------------------------------------ // Prepare input data - ov::Tensor fake_image = ov::test::utils::create_and_fill_tensor(ov::element::i8, {1, height, width, feature}, 50, 0, 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 50; + ov::Tensor fake_image = ov::test::utils::create_and_fill_tensor(ov::element::i8, {1, height, width, feature}, in_data); ov::Tensor fake_image_regular = ov::test::utils::create_and_fill_tensor(ov::element::f32, {1, height, width, feature }); auto image_ptr = static_cast(fake_image.data()); @@ -1364,8 +1367,12 @@ TEST_F(OVRemoteTensor_Test, NV12toBGR_image_ConvertTranspose) { // ------------------------------------------------------ // Prepare input data - ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1); - ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 50; + ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data); + in_data.range = 256; + ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data); auto ie = ov::Core(); @@ -1475,7 +1482,10 @@ TEST_F(OVRemoteTensor_Test, NV12toBGR_image_single_plane) { // ------------------------------------------------------ // Prepare input data - ov::Tensor fake_image_data_yuv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height * 3 / 2, width, 1}, 50); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 50; + ov::Tensor fake_image_data_yuv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height * 3 / 2, width, 1}, in_data); auto ie = ov::Core(); @@ -1565,8 +1575,12 @@ TEST_F(OVRemoteTensor_Test, NV12toBGR_image_two_planes) { // ------------------------------------------------------ // Prepare input data - ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1); - ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 50; + ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data); + in_data.range = 256; + ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data); auto ie = ov::Core(); @@ -1674,8 +1688,12 @@ TEST_F(OVRemoteTensor_Test, NV12toBGR_buffer) { // ------------------------------------------------------ // Prepare input data - ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1); - ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 50; + ov::Tensor fake_image_data_y = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data); + in_data.range = 256; + ov::Tensor fake_image_data_uv = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data); auto ie = ov::Core(); @@ -1776,8 +1794,12 @@ TEST_P(OVRemoteTensorBatched_Test, NV12toBGR_image_single_plane) { // Prepare input data std::vector fake_image_data_yuv; for (size_t i = 0; i < num_batch; i++) { - fake_image_data_yuv.push_back(ov::test::utils::create_and_fill_tensor( - ov::element::u8, {1, height * 3 / 2, width, 1}, 50, 0, 1, static_cast(i))); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 50; + in_data.resolution = 1; + in_data.seed = static_cast(i); + fake_image_data_yuv.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height * 3 / 2, width, 1}, in_data)); } auto ie = ov::Core(); @@ -1883,9 +1905,14 @@ TEST_P(OVRemoteTensorBatched_Test, NV12toBGR_image_two_planes) { // Prepare input data std::vector fake_image_data_y, fake_image_data_uv; for (size_t i = 0; i < num_batch; i++) { - fake_image_data_y.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1, static_cast(i))); - fake_image_data_uv.push_back(ov::test::utils::create_and_fill_tensor( - ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1, static_cast(i))); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 50; + in_data.resolution = 1; + in_data.seed = static_cast(i); + fake_image_data_y.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data)); + in_data.range = 256; + fake_image_data_uv.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data)); } auto ie = ov::Core(); @@ -2011,7 +2038,12 @@ TEST_P(OVRemoteTensorBatched_Test, NV12toGray) { std::vector fake_image; std::vector fake_image_regular; for (size_t i = 0; i < num_batch; i++) { - auto tensor_image = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, feature}, 50, 0, 1, static_cast(i)); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 50; + in_data.resolution = 1; + in_data.seed = static_cast(i); + auto tensor_image = ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, feature}, in_data); auto tensor_regular = ov::test::utils::create_and_fill_tensor(ov::element::f32, {1, feature, height, width }); auto image_ptr = static_cast(tensor_image.data()); auto image_ptr_regular = static_cast(tensor_regular.data()); @@ -2127,9 +2159,14 @@ TEST_P(OVRemoteTensorBatched_Test, NV12toBGR_buffer) { // Prepare input data std::vector fake_image_data_y, fake_image_data_uv; for (size_t i = 0; i < num_batch * 2; ++i) { - fake_image_data_y.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, 50, 0, 1, static_cast(i))); - fake_image_data_uv.push_back(ov::test::utils::create_and_fill_tensor( - ov::element::u8, {1, height / 2, width / 2, 2}, 256, 0, 1, static_cast(i))); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 50; + in_data.resolution = 1; + in_data.seed = static_cast(i); + fake_image_data_y.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height, width, 1}, in_data)); + in_data.range = 256; + fake_image_data_uv.push_back(ov::test::utils::create_and_fill_tensor(ov::element::u8, {1, height / 2, width / 2, 2}, in_data)); } auto ie = ov::Core(); diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/broadcast.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/broadcast.cpp index f09491bed63..6249b6f6159 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/broadcast.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/broadcast.cpp @@ -170,8 +170,11 @@ protected: } } else { if (funcInput.get_element_type().is_real()) { - tensor = ov::test::utils::create_and_fill_tensor( - funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/convolution_backprop_data.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/convolution_backprop_data.cpp index f34e155a5e6..473935bd799 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/convolution_backprop_data.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/convolution_backprop_data.cpp @@ -101,7 +101,11 @@ public: if (i == 1) { tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], outShapeData[inferRequestNum].data()); } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/detection_output.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/detection_output.cpp index 2b60747dbfa..9df68f3af86 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/detection_output.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/detection_output.cpp @@ -142,7 +142,11 @@ public: resolution = 10; } - auto tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], range, 0, resolution); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = range; + in_data.resolution = resolution; + auto tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } } diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_elements.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_elements.cpp index 6738aab04c5..804f6d42a6d 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_elements.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_elements.cpp @@ -56,7 +56,11 @@ public: const auto& funcInput = funcInputs[i]; ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 15, 0, 32768); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 15; + in_data.resolution = 32768; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_tree.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_tree.cpp index bc17b8775a7..ffedacd6bae 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_tree.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/gather_tree.cpp @@ -113,11 +113,11 @@ protected: const auto& funcInputs = function->inputs(); for (size_t i = 0; i < funcInputs.size(); ++i) { + ov::test::utils::InputGenerateData in_data; + in_data.start_from = (i == 2 || i == 3) ? maxBeamIndex / 2 : 0; + in_data.range = maxBeamIndex; auto tensor = - ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(), - targetInputStaticShapes[i], - maxBeamIndex, - (i == 2 || i == 3) ? maxBeamIndex / 2 : 0); + ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInputs[i].get_node_shared_ptr(), tensor}); } } diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/grid_sample.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/grid_sample.cpp index a115d2bc069..8c432154f73 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/grid_sample.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/grid_sample.cpp @@ -100,16 +100,19 @@ protected: for (size_t i = 0; i < funcInputs.size(); ++i) { const auto& funcInput = funcInputs[i]; ov::runtime::Tensor tensor; + ov::test::utils::InputGenerateData in_data; if (funcInput.get_node()->get_friendly_name() == "data") { int32_t range = std::accumulate(targetInputStaticShapes[0].begin(), targetInputStaticShapes[0].end(), 1u, std::multiplies()); - tensor = ov::test::utils::create_and_fill_tensor( - funcInput.get_element_type(), targetInputStaticShapes[0], range, -range / 2, 1); + in_data.start_from = -range / 2; + in_data.range = range; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data); } else if (funcInput.get_node()->get_friendly_name() == "grid") { int32_t range = std::max(targetInputStaticShapes[0][2], targetInputStaticShapes[0][3]) + 2; - int32_t resolution = range / 2; - tensor = ov::test::utils::create_and_fill_tensor( - funcInput.get_element_type(), targetInputStaticShapes[1], range, -1, resolution == 0 ? 1 : resolution); + in_data.start_from = -1; + in_data.range = range; + in_data.resolution = range / 2; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[1], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/group_convolution_backprop_data.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/group_convolution_backprop_data.cpp index 2141f5a935b..8a93e4b89b1 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/group_convolution_backprop_data.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/group_convolution_backprop_data.cpp @@ -102,7 +102,11 @@ public: if (i == 1) { tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], outShapeData[inferRequestNum].data()); } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/interpolate.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/interpolate.cpp index 5593fc22b45..133a515fe58 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/interpolate.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/interpolate.cpp @@ -111,7 +111,11 @@ public: ov::Tensor tensor; if (i == 0) { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 2560, 0, 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2560; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else if (i == 1) { if (shapeCalcMode == ov::op::v4::Interpolate::ShapeCalcMode::SIZES || funcInputs.size() == 3) { tensor = ov::Tensor(funcInput.get_element_type(), targetInputStaticShapes[i], sizes[inferRequestNum].data()); diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/pad.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/pad.cpp index da642f7f8ed..c18f3bfb8fa 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/pad.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/pad.cpp @@ -152,8 +152,11 @@ protected: data[0] = argPadValue; } else { if (funcInput.get_element_type().is_real()) { - tensor = ov::test::utils::create_and_fill_tensor( - funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/roi_pooling.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/roi_pooling.cpp index 2739442da2a..5c92531c41d 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/roi_pooling.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/roi_pooling.cpp @@ -149,7 +149,11 @@ protected: } } } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({ funcInput.get_node_shared_ptr(), tensor }); diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/scatter_nd_update.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/scatter_nd_update.cpp index fe0445cd291..6333dc12258 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/scatter_nd_update.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/scatter_nd_update.cpp @@ -104,7 +104,11 @@ protected: } } else { if (model_type.is_real()) { - tensor = ov::test::utils::create_and_fill_tensor(model_type, targetShape, 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(model_type, targetShape, in_data); } else { tensor = ov::test::utils::create_and_fill_tensor(model_type, targetShape); } diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/tile.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/tile.cpp index 9cf7d528eda..139ba609c1b 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/tile.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/tile.cpp @@ -116,8 +116,11 @@ protected: } } else { if (funcInput.get_element_type().is_real()) { - tensor = ov::test::utils::create_and_fill_tensor( - funcInput.get_element_type(), targetInputStaticShapes[i], 10, 0, 1000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 1000; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } else { tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/top_k.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/top_k.cpp index bc4bcb4bd72..d260b66331f 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/top_k.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/top_k.cpp @@ -133,10 +133,11 @@ protected: const auto& kPrecision = funcInputs[1].get_element_type(); const auto& kShape = targetInputStaticShapes[1]; - const size_t startFrom = 1; - const size_t range = targetInputStaticShapes[0][axis]; - const size_t seed = inferRequestNum++; - const auto kTensor = ov::test::utils::create_and_fill_tensor(kPrecision, kShape, range, startFrom, 1, seed); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = targetInputStaticShapes[0][axis]; + in_data.seed = inferRequestNum++; + const auto kTensor = ov::test::utils::create_and_fill_tensor(kPrecision, kShape, in_data); inputs.insert({funcInputs[1].get_node_shared_ptr(), kTensor}); } diff --git a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/unique.cpp b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/unique.cpp index 1362cc7a488..db5add50ded 100644 --- a/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/unique.cpp +++ b/src/plugins/intel_gpu/tests/functional/single_layer_tests/dynamic/unique.cpp @@ -108,11 +108,10 @@ protected: targetInputStaticShapes[0].end(), 1, std::multiplies()); - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[0], - range, - -range / 2, - 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -range / 2; + in_data.range = range; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[0], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/condition.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/condition.cpp index dbb6cef94c8..45d5a355d5e 100644 --- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/condition.cpp +++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/condition.cpp @@ -807,7 +807,12 @@ protected: inputs.insert({param, tensor}); } else { - auto tensor = ov::test::utils::create_and_fill_tensor(param->get_element_type(), input_shape, 10, 0, 128); + ov::test::utils::InputGenerateData inGenData; + inGenData.range = 10; + inGenData.start_from = 0; + inGenData.resolution = 128; + inGenData.seed = 1; + auto tensor = ov::test::utils::create_and_fill_tensor(param->get_element_type(), input_shape, inGenData); inputs.insert({param, tensor}); } } diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_model_static_split_layer.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_model_static_split_layer.cpp index 4f94d1a8dc2..e2825017ea8 100644 --- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_model_static_split_layer.cpp +++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_model_static_split_layer.cpp @@ -47,19 +47,19 @@ public: } protected: - void generate_inputs(const std::vector& targetInputStaticShapes) override { - inputs.clear(); - const auto& funcInputs = function->inputs(); - for (size_t i = 0; i < funcInputs.size(); ++i) { - const auto& funcInput = funcInputs[i]; - ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 80, - 0, - 8); - inputs.insert({funcInput.get_node_shared_ptr(), tensor}); - } + void generate_inputs(const std::vector& targetInputStaticShapes) override { + inputs.clear(); + const auto& funcInputs = function->inputs(); + for (size_t i = 0; i < funcInputs.size(); ++i) { + const auto& funcInput = funcInputs[i]; + ov::Tensor tensor; + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 80; + in_data.resolution = 8; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); + inputs.insert({funcInput.get_node_shared_ptr(), tensor}); + } } void SetUp() override { diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_gen_impl_key.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_gen_impl_key.cpp index 8daf22f14d0..f28ecbdbc6b 100644 --- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_gen_impl_key.cpp +++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_gen_impl_key.cpp @@ -54,17 +54,19 @@ public: } protected: - void generate_inputs(const std::vector& targetInputStaticShapes) override { - inputs.clear(); - const auto& funcInputs = function->inputs(); - for (size_t i = 0; i < funcInputs.size(); ++i) { - const auto& funcInput = funcInputs[i]; - ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 80, 0, 8); - inputs.insert({funcInput.get_node_shared_ptr(), tensor}); - } + void generate_inputs(const std::vector& targetInputStaticShapes) override { + inputs.clear(); + const auto& funcInputs = function->inputs(); + for (size_t i = 0; i < funcInputs.size(); ++i) { + const auto& funcInput = funcInputs[i]; + ov::Tensor tensor; + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 80; + in_data.resolution = 8; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); + inputs.insert({funcInput.get_node_shared_ptr(), tensor}); + } } void SetUp() override { diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_reduce_deconvolution_concat.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_reduce_deconvolution_concat.cpp index 83eb58eb777..7d8f4e089b2 100644 --- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_reduce_deconvolution_concat.cpp +++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_reduce_deconvolution_concat.cpp @@ -50,17 +50,19 @@ public: } protected: - void generate_inputs(const std::vector& targetInputStaticShapes) override { - inputs.clear(); - const auto& funcInputs = function->inputs(); - for (size_t i = 0; i < funcInputs.size(); ++i) { - const auto& funcInput = funcInputs[i]; - ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 80, 0, 8); - inputs.insert({funcInput.get_node_shared_ptr(), tensor}); - } + void generate_inputs(const std::vector& targetInputStaticShapes) override { + inputs.clear(); + const auto& funcInputs = function->inputs(); + for (size_t i = 0; i < funcInputs.size(); ++i) { + const auto& funcInput = funcInputs[i]; + ov::Tensor tensor; + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 80; + in_data.resolution = 8; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); + inputs.insert({funcInput.get_node_shared_ptr(), tensor}); + } } void SetUp() override { diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_activation.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_activation.cpp index 3e35dc00239..3afe0ccdb3b 100644 --- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_activation.cpp +++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_activation.cpp @@ -56,19 +56,19 @@ public: } protected: - void generate_inputs(const std::vector& targetInputStaticShapes) override { - inputs.clear(); - const auto& funcInputs = function->inputs(); - for (size_t i = 0; i < funcInputs.size(); ++i) { - const auto& funcInput = funcInputs[i]; - ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 80, - 0, - 8); - inputs.insert({funcInput.get_node_shared_ptr(), tensor}); - } + void generate_inputs(const std::vector& targetInputStaticShapes) override { + inputs.clear(); + const auto& funcInputs = function->inputs(); + for (size_t i = 0; i < funcInputs.size(); ++i) { + const auto& funcInput = funcInputs[i]; + ov::Tensor tensor; + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 80; + in_data.resolution = 8; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); + inputs.insert({funcInput.get_node_shared_ptr(), tensor}); + } } void SetUp() override { diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_reduce_reshape.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_reduce_reshape.cpp index 9965777b798..4a3433660e1 100644 --- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_reduce_reshape.cpp +++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_shape_of_reduce_reshape.cpp @@ -52,17 +52,19 @@ public: } protected: - void generate_inputs(const std::vector& targetInputStaticShapes) override { - inputs.clear(); - const auto& funcInputs = function->inputs(); - for (size_t i = 0; i < funcInputs.size(); ++i) { - const auto& funcInput = funcInputs[i]; - ov::Tensor tensor; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 80, 0, 8); - inputs.insert({funcInput.get_node_shared_ptr(), tensor}); - } + void generate_inputs(const std::vector& targetInputStaticShapes) override { + inputs.clear(); + const auto& funcInputs = function->inputs(); + for (size_t i = 0; i < funcInputs.size(); ++i) { + const auto& funcInput = funcInputs[i]; + ov::Tensor tensor; + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 80; + in_data.resolution = 8; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); + inputs.insert({funcInput.get_node_shared_ptr(), tensor}); + } } void SetUp() override { diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_with_empty_tensor.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_with_empty_tensor.cpp index 398eb1ab8ee..88ceb3ea6db 100644 --- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_with_empty_tensor.cpp +++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/dynamic_smoke_test_with_empty_tensor.cpp @@ -49,26 +49,28 @@ public: } protected: - void generate_inputs(const std::vector& targetInputStaticShapes) override { - inputs.clear(); - const auto& funcInputs = function->inputs(); - for (size_t i = 0; i < funcInputs.size(); ++i) { - auto node = funcInputs[i].get_node_shared_ptr(); - auto tensor = ov::runtime::Tensor(node->get_element_type(), targetInputStaticShapes[i]); - if (i == 0) { - // All zero inputs for non_zero op - auto tensor_ptr = static_cast(tensor.data()); - for (size_t j = 0; j < ov::shape_size(targetInputStaticShapes[i]); ++j) { - tensor_ptr[j] = 0; - } - } else { - // Random inputs for concat - tensor = ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(), - targetInputStaticShapes[i], - 80, 0, 8); + void generate_inputs(const std::vector& targetInputStaticShapes) override { + inputs.clear(); + const auto& funcInputs = function->inputs(); + for (size_t i = 0; i < funcInputs.size(); ++i) { + auto node = funcInputs[i].get_node_shared_ptr(); + auto tensor = ov::runtime::Tensor(node->get_element_type(), targetInputStaticShapes[i]); + if (i == 0) { + // All zero inputs for non_zero op + auto tensor_ptr = static_cast(tensor.data()); + for (size_t j = 0; j < ov::shape_size(targetInputStaticShapes[i]); ++j) { + tensor_ptr[j] = 0; } - inputs.insert({funcInputs[i].get_node_shared_ptr(), tensor}); - } + } else { + // Random inputs for concat + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 80; + in_data.resolution = 8; + tensor = ov::test::utils::create_and_fill_tensor(funcInputs[i].get_element_type(), targetInputStaticShapes[i], in_data); + } + inputs.insert({funcInputs[i].get_node_shared_ptr(), tensor}); + } } void SetUp() override { diff --git a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/matmul_weights_decompression.cpp b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/matmul_weights_decompression.cpp index d6c5dbe7353..9a439132af0 100644 --- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/matmul_weights_decompression.cpp +++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/matmul_weights_decompression.cpp @@ -192,7 +192,11 @@ protected: mul_parent = std::make_shared(weights_convert, shift_convert); } - auto scale_tensor = ov::test::utils::create_and_fill_tensor(data_precision, scaleshift_const_shape, 1, -0.5, 30000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -0.5; + in_data.range = 1; + in_data.resolution = 30000; + auto scale_tensor = ov::test::utils::create_and_fill_tensor(data_precision, scaleshift_const_shape, in_data); for (size_t i = 0; i < scale_tensor.get_size(); i++) { if (data_precision == ov::element::f16) scale_tensor.data()[i] /= ov::float16(16.f); @@ -270,9 +274,11 @@ protected: const auto& model_inputs = function->inputs(); for (size_t i = 0; i < model_inputs.size(); ++i) { const auto& model_input = model_inputs[i]; - ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), - target_input_static_shapes[i], - 2, -1, 10000); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -1; + in_data.range = 2; + in_data.resolution = 10000; + ov::Tensor tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), target_input_static_shapes[i], in_data); inputs.insert({model_input.get_node_shared_ptr(), tensor}); } } diff --git a/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/read_ir/read_ir.cpp b/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/read_ir/read_ir.cpp index 34201bdba90..5704638abe3 100644 --- a/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/read_ir/read_ir.cpp +++ b/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/read_ir/read_ir.cpp @@ -139,7 +139,7 @@ void ReadIRTest::SetUp() { if (!in_info.is_const) { continue; } - utils::ConstRanges::set(in_info.ranges.min, in_info.ranges.max); + ov::test::utils::set_const_ranges(in_info.ranges.min, in_info.ranges.max); // auto next_node = param->get_default_output().get_node_shared_ptr(); auto next_node = param->get_default_output().get_target_inputs().begin()->get_node()->shared_from_this(); auto it = inputMap.find(next_node->get_type_info()); @@ -148,7 +148,7 @@ void ReadIRTest::SetUp() { const_node->set_friendly_name(param->get_friendly_name()); ov::replace_node(param, const_node); parameter_to_remove.push_back(param); - utils::ConstRanges::reset(); + ov::test::utils::reset_const_ranges(); } for (const auto& param : parameter_to_remove) { function->remove_parameter(param); diff --git a/src/tests/functional/plugin/shared/src/behavior/ov_infer_request/infer_request_dynamic.cpp b/src/tests/functional/plugin/shared/src/behavior/ov_infer_request/infer_request_dynamic.cpp index 029c903aa3a..7390c072674 100644 --- a/src/tests/functional/plugin/shared/src/behavior/ov_infer_request/infer_request_dynamic.cpp +++ b/src/tests/functional/plugin/shared/src/behavior/ov_infer_request/infer_request_dynamic.cpp @@ -93,7 +93,10 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetwork) { ov::InferRequest req; const std::string outputname = function->outputs().back().get_any_name(); for (auto& shape : vectorShapes) { - ov::runtime::Tensor inTensor = ov::test::utils::create_and_fill_tensor(element::f32, shape, 100, -50); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -50; + in_data.range = 100; + ov::runtime::Tensor inTensor = ov::test::utils::create_and_fill_tensor(element::f32, shape, in_data); OV_ASSERT_NO_THROW(req = execNet.create_infer_request()); OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", inTensor)); OV_ASSERT_NO_THROW(req.infer()); @@ -115,11 +118,15 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetworkSetUnexpectedOutputTensorB ov::runtime::Tensor tensor, otensor; const std::string outputname = function->outputs().back().get_any_name(); OV_ASSERT_NO_THROW(req = execNet.create_infer_request()); - tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, 100, -50); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -50; + in_data.range = 100; + tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, in_data); OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", tensor)); auto outShape = refOutShape; outShape[0] += 1; - otensor = ov::test::utils::create_and_fill_tensor(element::f32, outShape, 100, 50); + in_data.start_from = 50; + otensor = ov::test::utils::create_and_fill_tensor(element::f32, outShape, in_data); OV_ASSERT_NO_THROW(req.set_tensor(outputname, otensor)); OV_ASSERT_NO_THROW(req.infer()); ASSERT_EQ(otensor.get_shape(), refOutShape); @@ -140,7 +147,10 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetworkSetOutputTensorPreAllocate ov::runtime::Tensor tensor; const std::string outputname = function->outputs().back().get_any_name(); OV_ASSERT_NO_THROW(req = execNet.create_infer_request()); - tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, 100, -50); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -50; + in_data.range = 100; + tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, in_data); OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", tensor)); float ptr[5000]; ov::runtime::Tensor otensor(element::f32, refOutShape, ptr); @@ -165,7 +175,10 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetworkSetOutputShapeBeforeInfer) ov::runtime::Tensor tensor, otensor; const std::string outputname = function->outputs().back().get_any_name(); OV_ASSERT_NO_THROW(req = execNet.create_infer_request()); - tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, 100, -50); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -50; + in_data.range = 100; + tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, in_data); OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", tensor)); OV_ASSERT_NO_THROW(otensor = req.get_tensor(outputname)); OV_ASSERT_NO_THROW(otensor.set_shape(refOutShape)); @@ -189,7 +202,10 @@ TEST_P(OVInferRequestDynamicTests, InferDynamicNetworkGetOutputThenSetOutputTens ov::runtime::Tensor tensor; const std::string outputname = function->outputs().back().get_any_name(); OV_ASSERT_NO_THROW(req = execNet.create_infer_request()); - tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, 100, -50); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -50; + in_data.range = 100; + tensor = ov::test::utils::create_and_fill_tensor(element::f32, refShape, in_data); OV_ASSERT_NO_THROW(req.set_tensor("input_tensor", tensor)); // first, get ouput tensor OV_ASSERT_NO_THROW(req.infer()); diff --git a/src/tests/functional/plugin/shared/src/snippets/convert.cpp b/src/tests/functional/plugin/shared/src/snippets/convert.cpp index af37875d50f..0112c18c162 100644 --- a/src/tests/functional/plugin/shared/src/snippets/convert.cpp +++ b/src/tests/functional/plugin/shared/src/snippets/convert.cpp @@ -86,8 +86,11 @@ void Convert::generate_inputs(const std::vector& targetInputStaticSha ov::Tensor tensor; int32_t startFrom, range, resolution; std::tie(startFrom, range, resolution) = params[i]; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], - range, startFrom, resolution); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = startFrom; + in_data.range = range; + in_data.resolution = resolution; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); inputs.insert({funcInput.get_node_shared_ptr(), tensor}); } } diff --git a/src/tests/functional/plugin/shared/src/snippets/mha.cpp b/src/tests/functional/plugin/shared/src/snippets/mha.cpp index f98241202da..6603a1d8183 100644 --- a/src/tests/functional/plugin/shared/src/snippets/mha.cpp +++ b/src/tests/functional/plugin/shared/src/snippets/mha.cpp @@ -81,9 +81,12 @@ void MHA::generate_inputs(const std::vector& targetInputStaticSha for (int i = 0; i < model_inputs.size(); ++i) { const auto& model_input = model_inputs[i]; ov::Tensor tensor; + ov::test::utils::InputGenerateData in_data; // To avoid big relative errors in the vicinity of zero, only positive values are generated for bf16 precision - int start_from = model_input.get_element_type() == ov::element::bf16 ? 0 : -1; - tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), 2, start_from, 256); + in_data.start_from = model_input.get_element_type() == ov::element::bf16 ? 0 : -1; + in_data.range = 2; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), in_data); inputs.insert({model_input.get_node_shared_ptr(), tensor}); } } @@ -101,10 +104,19 @@ void MHASelect::generate_inputs(const std::vector& targetInputSta ov::Tensor tensor; int seed = 0; if (name.find("less") != std::string::npos) { - tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), 5 + seed, -2, 10, seed); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -2; + in_data.range = 5 + seed; + in_data.resolution = 10; + in_data.seed = seed; + tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), in_data); seed++; } else { - tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), 2, -1, 256); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -1; + in_data.range = 2; + in_data.resolution = 256; + tensor = ov::test::utils::create_and_fill_tensor(model_input.get_element_type(), model_input.get_shape(), in_data); } inputs.insert({node_input, tensor}); } diff --git a/src/tests/functional/plugin/shared/src/snippets/select.cpp b/src/tests/functional/plugin/shared/src/snippets/select.cpp index 37911036a85..ea5ab8e1f0a 100644 --- a/src/tests/functional/plugin/shared/src/snippets/select.cpp +++ b/src/tests/functional/plugin/shared/src/snippets/select.cpp @@ -16,9 +16,21 @@ namespace { void generate_data(std::map, ov::Tensor>& data_inputs, const std::vector>& model_inputs, const std::vector& targetInputStaticShapes) { data_inputs.clear(); - auto tensor_bool = ov::test::utils::create_and_fill_tensor(model_inputs[0].get_element_type(), targetInputStaticShapes[0], 3, -1, 2); - auto tensor0 = ov::test::utils::create_and_fill_tensor(model_inputs[1].get_element_type(), targetInputStaticShapes[1], 10, -10, 2); - auto tensor1 = ov::test::utils::create_and_fill_tensor(model_inputs[2].get_element_type(), targetInputStaticShapes[2], 10, 0, 2); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -1; + in_data.range = 3; + in_data.resolution = 2; + auto tensor_bool = ov::test::utils::create_and_fill_tensor(model_inputs[0].get_element_type(), targetInputStaticShapes[0], in_data); + + in_data.start_from = -10; + in_data.range = 10; + in_data.resolution = 2; + auto tensor0 = ov::test::utils::create_and_fill_tensor(model_inputs[1].get_element_type(), targetInputStaticShapes[1], in_data); + + in_data.start_from = 0; + in_data.range = 10; + in_data.resolution = 2; + auto tensor1 = ov::test::utils::create_and_fill_tensor(model_inputs[2].get_element_type(), targetInputStaticShapes[2], in_data); data_inputs.insert({model_inputs[0].get_node_shared_ptr(), tensor_bool}); data_inputs.insert({model_inputs[1].get_node_shared_ptr(), tensor0}); data_inputs.insert({model_inputs[2].get_node_shared_ptr(), tensor1}); diff --git a/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/generate_inputs.hpp b/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/generate_inputs.hpp index 0ea5ec20e78..980483e2317 100644 --- a/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/generate_inputs.hpp +++ b/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/generate_inputs.hpp @@ -13,6 +13,9 @@ namespace ov { namespace test { namespace utils { +void set_const_ranges(double _min, double _max); +void reset_const_ranges(); + using InputsMap = std::map& node, size_t port, diff --git a/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/ranges.hpp b/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/ranges.hpp index e134bd7f018..bdcdd94fd27 100644 --- a/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/ranges.hpp +++ b/src/tests/functional/shared_test_classes/include/shared_test_classes/base/utils/ranges.hpp @@ -7,22 +7,25 @@ #include #include -#include "ngraph/node.hpp" -#include "ngraph/op/proposal.hpp" -#include "ngraph/op/power.hpp" -#include "ngraph/op/mod.hpp" -#include "ngraph/op/floor_mod.hpp" -#include "ngraph/op/divide.hpp" -#include "ngraph/op/erf.hpp" -#include "ngraph/op/non_max_suppression.hpp" -#include "ngraph/op/reduce_l1.hpp" -#include "ngraph/op/reduce_l2.hpp" -#include "ngraph/op/reduce_sum.hpp" -#include "ngraph/op/reduce_prod.hpp" -#include "ngraph/op/reduce_mean.hpp" -#include "ngraph/op/max.hpp" -#include "ngraph/op/min.hpp" +#include "common_test_utils/ov_tensor_utils.hpp" +#include "openvino/core/node.hpp" +#include "openvino/op/proposal.hpp" +#include "openvino/op/power.hpp" +#include "openvino/op/mod.hpp" +#include "openvino/op/floor_mod.hpp" +#include "openvino/op/divide.hpp" +#include "openvino/op/erf.hpp" +#include "openvino/op/non_max_suppression.hpp" +#include "openvino/op/reduce_l1.hpp" +#include "openvino/op/reduce_l2.hpp" +#include "openvino/op/reduce_sum.hpp" +#include "openvino/op/reduce_prod.hpp" +#include "openvino/op/reduce_mean.hpp" +#include "openvino/op/maximum.hpp" +#include "openvino/op/minimum.hpp" +#include "openvino/op/reduce_max.hpp" +#include "openvino/op/reduce_min.hpp" #include "openvino/op/dft.hpp" #include "openvino/op/idft.hpp" #include "openvino/op/logical_and.hpp" @@ -72,45 +75,7 @@ namespace ov { namespace test { namespace utils { -// todo: remove w/a to generate correct constant data (replace parameter to const) in conformance with defined range -struct ConstRanges { - static double max, min; - static bool is_defined; - - static void set(double _min, double _max) { - min = _min; - max = _max; - is_defined = true; - } - - static void reset() { - min = std::numeric_limits::max(); - max = std::numeric_limits::min(); - is_defined = false; - } -}; - -struct InputGenerateData { - double_t start_from; - uint32_t range; - int32_t resolution; - int seed; - - InputGenerateData(double_t _start_from = 0, uint32_t _range = 10, int32_t _resolution = 1, int _seed = 1) - : start_from(_start_from), range(_range), resolution(_resolution), seed(_seed) { - if (ConstRanges::is_defined) { - auto min_orig = start_from; - auto max_orig = start_from + range * resolution; - auto min_ref = ConstRanges::min; - auto max_ref = ConstRanges::max; - if (min_orig < min_ref || min_orig == 0) - start_from = min_ref; - range = (max_orig > max_ref || max_orig == 10 ? max_ref : max_orig - start_from) - start_from; - } - } -}; - -static std::map>> inputRanges = { +static std::map>> inputRanges = { // NodeTypeInfo: {IntRanges{}, RealRanges{}} (Ranges are used by generate) { ov::op::v0::Erf::get_type_info_static(), {{{-3, 6}}, {{-3, 6, 10}}} }, { ov::op::v1::Divide::get_type_info_static(), {{{101, 100}}, {{2, 2, 128}}} }, diff --git a/src/tests/functional/shared_test_classes/src/base/utils/generate_inputs.cpp b/src/tests/functional/shared_test_classes/src/base/utils/generate_inputs.cpp index 885c9daaf1f..306e145729d 100644 --- a/src/tests/functional/shared_test_classes/src/base/utils/generate_inputs.cpp +++ b/src/tests/functional/shared_test_classes/src/base/utils/generate_inputs.cpp @@ -20,9 +20,23 @@ namespace ov { namespace test { namespace utils { -double ConstRanges::max = std::numeric_limits::min(); -double ConstRanges::min = std::numeric_limits::max(); -bool ConstRanges::is_defined = false; +namespace { +struct { + double max = 0; + double min = 0; + bool is_defined = false; +} const_range; +} // namespace + +void set_const_ranges(double _min, double _max) { + const_range.max = _max; + const_range.min = _min; + const_range.is_defined = true; +} + +void reset_const_ranges() { + const_range.is_defined = false; +} namespace { @@ -43,6 +57,10 @@ namespace { * * All the generated numbers completely fit into the data type without truncation */ + +using ov::test::utils::InputGenerateData; + + static inline void set_real_number_generation_data(InputGenerateData& inGenData) { inGenData.range = 8; inGenData.resolution = 32; @@ -53,6 +71,17 @@ ov::runtime::Tensor generate(const std::shared_ptr& node, const ov::element::Type& elemType, const ov::Shape& targetShape) { InputGenerateData inGenData; + + if (const_range.is_defined) { + auto min_orig = inGenData.start_from; + auto max_orig = inGenData.start_from + inGenData.range * inGenData.resolution; + auto min_ref = const_range.min; + auto max_ref = const_range.max; + if (min_orig < min_ref || min_orig == 0) + inGenData.start_from = min_ref; + inGenData.range = (max_orig > max_ref || max_orig == 10 ? max_ref : max_orig - inGenData.start_from) - inGenData.start_from; + } + if (elemType.is_real()) { set_real_number_generation_data(inGenData); } @@ -67,8 +96,7 @@ ov::runtime::Tensor generate(const std::shared_ptr& node, const auto& range = ranges.at(elemType.is_real()); inGenData = range.size() < inNodeCnt ? range.front() : range.at(port); } - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, - inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } namespace Activation { @@ -79,7 +107,7 @@ ov::runtime::Tensor generate(const ov::element::Type& elemType, inGenData.range = 15; inGenData.start_from = 0; } - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } } // namespace Activation @@ -89,10 +117,16 @@ ov::runtime::Tensor generate(const std::shared_ptr& const ov::Shape& targetShape) { switch (port) { case 1: { - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, 0, 0.2f); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0.2; + in_data.range = 0; + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data); } case 2: { - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, 0, 0.5f); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0.5; + in_data.range = 0; + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data); } default: { return Activation::generate(elemType, targetShape); @@ -110,9 +144,15 @@ ov::runtime::Tensor generate(const std::shared_ptr& node, case 1: { auto name = node->input(1).get_node()->get_friendly_name(); if (0 == name.compare("leakySlope")) { - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, 0, 0.01f, 100); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0.01; + in_data.range = 0; + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data); } else if (0 == name.compare("negativeSlope")) { - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, 0, -0.01f, 100); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -0.01; + in_data.range = 0; + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data); } else { return Activation::generate(elemType, targetShape); } @@ -166,7 +206,7 @@ ov::runtime::Tensor generate(const std::shared_ptr& node, @@ -225,7 +265,7 @@ ov::runtime::Tensor generate(const std::shared_ptr inGenData.resolution = 1.0f; inGenData.seed = seed; - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } } } @@ -307,19 +347,22 @@ ov::runtime::Tensor generate(const std::shared_ptr& InputGenerateData inGenData; inGenData.start_from = maxBeamIndx / 2; inGenData.range = maxBeamIndx; - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } default: InputGenerateData inGenData; inGenData.range = maxBeamIndx; - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } } namespace LogicalOp { ov::runtime::Tensor generate(const ov::element::Type& elemType, const ov::Shape& targetShape) { - return create_and_fill_tensor(elemType, targetShape, 2, 0); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 2; + return create_and_fill_tensor(elemType, targetShape, in_data); } } @@ -373,7 +416,12 @@ ov::runtime::Tensor generate(const std::shared_ptr& n switch (port) { case 0: { auto data_size = shape_size(targetShape); - return create_and_fill_tensor(elemType, targetShape, data_size * 5, 0, 10, 7235346); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = data_size * 5; + in_data.resolution = 10; + in_data.seed = 7235346; + return create_and_fill_tensor(elemType, targetShape, in_data); } case 1: { return create_and_fill_tensor_unique_sequence(elemType, targetShape, 0, 10, 8234231); @@ -446,8 +494,10 @@ ov::runtime::Tensor generate(const std::shared_ptr& const ov::element::Type& elemType, const ov::Shape& targetShape) { if (port == 2) { - unsigned int m_max_seq_len = 10; - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, m_max_seq_len, 0); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; // max_seq_len + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data); } return generate(std::dynamic_pointer_cast(node), port, elemType, targetShape); } @@ -457,12 +507,16 @@ ov::runtime::Tensor generate(const std::shared_ptr& no const ov::element::Type& elemType, const ov::Shape& targetShape) { if (port == 2) { - unsigned int m_max_seq_len = 10; - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, m_max_seq_len, 0); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; // max_seq_len + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data); } if (port == 3 && node->input(0).get_partial_shape().is_static()) { - auto seq_len = node->input(0).get_shape()[1]; - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, seq_len); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = node->input(0).get_shape()[1]; // seq_len + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data); } return generate(std::dynamic_pointer_cast(node), port, elemType, targetShape); } @@ -593,8 +647,10 @@ ov::runtime::Tensor generate(const std::shared_ptr& const ov::element::Type& elemType, const ov::Shape& targetShape) { if (port == 2) { - unsigned int m_max_seq_len = 10; - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, m_max_seq_len, 0); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 10; // max_seq_len + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_data); } return generate(std::dynamic_pointer_cast(node), port, elemType, targetShape); } @@ -769,8 +825,7 @@ ov::runtime::Tensor generate(const in_gen_data.start_from = 0; in_gen_data.resolution = 20; } - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_gen_data.range, - in_gen_data.start_from, in_gen_data.resolution, in_gen_data.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, in_gen_data); } namespace comparison { @@ -972,7 +1027,7 @@ ov::runtime::Tensor generate(const const ov::Shape& targetShape) { if (port == 0) { InputGenerateData inGenData(-5, 10, 7, 222); - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } return generate(std::dynamic_pointer_cast(node), port, elemType, targetShape); } @@ -983,7 +1038,7 @@ ov::runtime::Tensor generate(const const ov::element::Type& elemType, const ov::Shape& targetShape) { InputGenerateData inGenData(1, 0, 1, 1); - auto tensor = ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + auto tensor = ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); if (0 == port || 1 == port) { #define CASE(X) case X: { \ @@ -1017,7 +1072,7 @@ ov::runtime::Tensor generate(const const ov::element::Type& elemType, const ov::Shape& targetShape) { InputGenerateData inGenData(1, 0, 1, 1); - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } ov::runtime::Tensor generate(const @@ -1031,7 +1086,7 @@ ov::runtime::Tensor generate(const inGenData.range = 200; inGenData.resolution = 2; } - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } ov::runtime::Tensor generate(const @@ -1041,7 +1096,7 @@ ov::runtime::Tensor generate(const const ov::Shape& targetShape) { if (port == 1) { InputGenerateData inGenData(0, 1, 1000, 1); - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } return generate(std::dynamic_pointer_cast(node), port, elemType, targetShape); } @@ -1053,7 +1108,7 @@ ov::runtime::Tensor generate(const const ov::Shape& targetShape) { if (port == 1) { InputGenerateData inGenData(0, 1, 1000, 1); - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } return generate(std::dynamic_pointer_cast(node), port, elemType, targetShape); } @@ -1065,7 +1120,7 @@ ov::runtime::Tensor generate(const const ov::Shape& targetShape) { if (port == 1) { InputGenerateData inGenData(0, 1, 1000, 1); - return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData.range, inGenData.start_from, inGenData.resolution, inGenData.seed); + return ov::test::utils::create_and_fill_tensor(elemType, targetShape, inGenData); } return generate(std::dynamic_pointer_cast(node), port, elemType, targetShape); } diff --git a/src/tests/functional/shared_test_classes/src/single_layer/gather_elements.cpp b/src/tests/functional/shared_test_classes/src/single_layer/gather_elements.cpp index 09ee2fb120e..ce5b6b869ab 100644 --- a/src/tests/functional/shared_test_classes/src/single_layer/gather_elements.cpp +++ b/src/tests/functional/shared_test_classes/src/single_layer/gather_elements.cpp @@ -48,7 +48,10 @@ void GatherElementsLayerTest::SetUp() { posAxis += dataShape.size(); const auto axisDim = dataShape[posAxis]; - auto indicesValues = ov::test::utils::create_and_fill_tensor(ov::element::i32, indicesShape, axisDim - 1, 0); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = axisDim - 1; + auto indicesValues = ov::test::utils::create_and_fill_tensor(ov::element::i32, indicesShape, in_data); auto indicesNode = std::make_shared(indicesValues); auto gather = std::make_shared(params[0], indicesNode, axis); diff --git a/src/tests/functional/shared_test_classes/src/single_op/batch_norm.cpp b/src/tests/functional/shared_test_classes/src/single_op/batch_norm.cpp index f2df32ba504..1305d115fc6 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/batch_norm.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/batch_norm.cpp @@ -40,18 +40,23 @@ void BatchNormLayerTest::SetUp() { init_input_shapes(shapes); ov::ParameterVector params {std::make_shared(model_type, inputDynamicShapes.front())}; + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = 1; + auto constant_shape = ov::Shape{params[0]->get_shape().at(1)}; - auto gamma_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, 1, 0); + auto gamma_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, in_data); auto gamma = std::make_shared(gamma_tensor); - auto beta_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, 1, 0); + auto beta_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, in_data); auto beta = std::make_shared(beta_tensor); - auto mean_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, 1, 0); + auto mean_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, in_data); auto mean = std::make_shared(mean_tensor); // Fill the vector for variance with positive values - auto variance_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, 10, 0); + in_data.range = 10; + auto variance_tensor = ov::test::utils::create_and_fill_tensor(model_type, constant_shape, in_data); auto variance = std::make_shared(variance_tensor); auto batch_norm = std::make_shared(params[0], gamma, beta, mean, variance, epsilon); diff --git a/src/tests/functional/shared_test_classes/src/single_op/eltwise.cpp b/src/tests/functional/shared_test_classes/src/single_op/eltwise.cpp index f4790c91d47..1f9c837995e 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/eltwise.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/eltwise.cpp @@ -105,21 +105,28 @@ void EltwiseLayerTest::SetUp() { parameters.push_back(param); } else { ov::Shape shape = inputDynamicShapes.back().get_max_shape(); + ov::test::utils::InputGenerateData in_data; switch (eltwise_type) { case EltwiseTypes::DIVIDE: case EltwiseTypes::MOD: case EltwiseTypes::FLOOR_MOD: { - auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, 8, 2); + in_data.start_from = 2; + in_data.range = 8; + auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, in_data); secondary_input = std::make_shared(tensor); break; } case EltwiseTypes::POWER: { - auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, 2, 1); + in_data.start_from = 1; + in_data.range = 2; + auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, in_data); secondary_input = std::make_shared(tensor); break; } default: { - auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, 9, 1); + in_data.start_from = 1; + in_data.range = 9; + auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, in_data); secondary_input = std::make_shared(tensor); } } diff --git a/src/tests/functional/shared_test_classes/src/single_op/gather.cpp b/src/tests/functional/shared_test_classes/src/single_op/gather.cpp index f4c91752190..d320aa16806 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/gather.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/gather.cpp @@ -104,7 +104,10 @@ void Gather7LayerTest::SetUp() { auto param = std::make_shared(model_type, inputDynamicShapes.front()); int axis_dim = targetStaticShapes[0][0][axis < 0 ? axis + targetStaticShapes[0][0].size() : axis]; - auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, indices_shape, axis_dim - 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = axis_dim - 1; + auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, indices_shape, in_data); auto indices_node = std::make_shared(indices_node_tensor); auto axis_node = ov::op::v0::Constant::create(ov::element::i64, ov::Shape(), {axis}); @@ -132,7 +135,10 @@ void Gather8LayerTest::SetUp() { auto param = std::make_shared(model_type, inputDynamicShapes.front()); int axis_dim = targetStaticShapes[0][0][axis < 0 ? axis + targetStaticShapes[0][0].size() : axis]; - auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, indices_shape, 2 * axis_dim, -axis_dim); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -axis_dim; + in_data.range = 2 * axis_dim; + auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, indices_shape, in_data); auto indices_node = std::make_shared(indices_node_tensor); auto axis_node = ov::op::v0::Constant::create(ov::element::i64, ov::Shape(), {axis}); diff --git a/src/tests/functional/shared_test_classes/src/single_op/gather_elements.cpp b/src/tests/functional/shared_test_classes/src/single_op/gather_elements.cpp index 1366ff6505b..5d617bde3a4 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/gather_elements.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/gather_elements.cpp @@ -52,7 +52,10 @@ void GatherElementsLayerTest::SetUp() { auto param = std::make_shared(model_type, inputDynamicShapes.front()); auto axis_dim = targetStaticShapes[0][0][axis < 0 ? axis + targetStaticShapes[0][0].size() : axis]; - auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(indices_type, indices_shape, axis_dim - 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = axis_dim - 1; + auto indices_node_tensor = ov::test::utils::create_and_fill_tensor(indices_type, indices_shape, in_data); auto indices_node = std::make_shared(indices_node_tensor); auto gather_el = std::make_shared(param, indices_node, axis); diff --git a/src/tests/functional/shared_test_classes/src/single_op/gather_tree.cpp b/src/tests/functional/shared_test_classes/src/single_op/gather_tree.cpp index 3847b1f6bae..d98ca8a62b0 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/gather_tree.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/gather_tree.cpp @@ -59,7 +59,10 @@ void GatherTreeLayerTest::SetUp() { } for (const auto& shape : constant_shapes_static) { - auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, input_shape.at(2) - 2, 1); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 1; + in_data.range = input_shape.at(2) - 2; + auto tensor = ov::test::utils::create_and_fill_tensor(model_type, shape, in_data); auto constant = std::make_shared(tensor); inputs.push_back(constant); } diff --git a/src/tests/functional/shared_test_classes/src/single_op/gru_sequence.cpp b/src/tests/functional/shared_test_classes/src/single_op/gru_sequence.cpp index 81ae8ceb175..e7037267cdb 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/gru_sequence.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/gru_sequence.cpp @@ -97,7 +97,10 @@ void GRUSequenceTest::SetUp() { seq_lengths_node = param; } else if (mode == SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST || mode == SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST) { - auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, targetStaticShapes[0][2], seq_lengths, 0); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = seq_lengths; + auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, targetStaticShapes[0][2], in_data); seq_lengths_node = std::make_shared(tensor); } else { std::vector lengths(batch, seq_lengths); diff --git a/src/tests/functional/shared_test_classes/src/single_op/lstm_sequence.cpp b/src/tests/functional/shared_test_classes/src/single_op/lstm_sequence.cpp index 514557ead7a..2f680cacfea 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/lstm_sequence.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/lstm_sequence.cpp @@ -116,7 +116,10 @@ void LSTMSequenceTest::SetUp() { params.push_back(param); } else if (mode == SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST || mode == SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST) { - auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, inputShapes[3], seq_lengths); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = seq_lengths; + auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, inputShapes[3], in_data); seq_lengths_node = std::make_shared(tensor); } else { std::vector lengths(inputShapes[3][0], seq_lengths); diff --git a/src/tests/functional/shared_test_classes/src/single_op/multiclass_nms.cpp b/src/tests/functional/shared_test_classes/src/single_op/multiclass_nms.cpp index 3aa95a61691..7a5829fd570 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/multiclass_nms.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/multiclass_nms.cpp @@ -66,7 +66,8 @@ void MulticlassNmsLayerTest::generate_inputs(const std::vector& targe const size_t start_from = 0; const size_t k = 1000; const int seed = 1; - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], range, start_from, k, seed); + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], + ov::test::utils::InputGenerateData(start_from, range, k, seed)); } else if (i == 0) { // bboxes tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i]); } else { // roisnum diff --git a/src/tests/functional/shared_test_classes/src/single_op/rnn_sequence.cpp b/src/tests/functional/shared_test_classes/src/single_op/rnn_sequence.cpp index 109aacdacbc..e79cd38ab65 100644 --- a/src/tests/functional/shared_test_classes/src/single_op/rnn_sequence.cpp +++ b/src/tests/functional/shared_test_classes/src/single_op/rnn_sequence.cpp @@ -85,7 +85,10 @@ void RNNSequenceTest::SetUp() { seq_lengths_node = param; } else if (mode == ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST || mode == ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST) { - auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, input_shapes[2], static_cast(seq_lengths), 0.f); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = seq_lengths; + auto tensor = ov::test::utils::create_and_fill_tensor(ov::element::i64, input_shapes[2], in_data); seq_lengths_node = std::make_shared(tensor); } else { std::vector lengths(batch, seq_lengths); diff --git a/src/tests/functional/shared_test_classes/src/subgraph/simple_if.cpp b/src/tests/functional/shared_test_classes/src/subgraph/simple_if.cpp index 7d2fc5a1d9c..20c51a963ac 100644 --- a/src/tests/functional/shared_test_classes/src/subgraph/simple_if.cpp +++ b/src/tests/functional/shared_test_classes/src/subgraph/simple_if.cpp @@ -175,10 +175,10 @@ void SimpleIfNotConstConditionTest::generate_inputs(const std::vector auto* dataPtr = tensor.data(); dataPtr[0] = condition; } else { - tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), - targetInputStaticShapes[i], - 10, - -5); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -5; + in_data.range = 10; + tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(), targetInputStaticShapes[i], in_data); } inputs.insert({funcInput.get_node_shared_ptr(), tensor}); diff --git a/src/tests/test_utils/common_test_utils/include/common_test_utils/ov_tensor_utils.hpp b/src/tests/test_utils/common_test_utils/include/common_test_utils/ov_tensor_utils.hpp index 5bb12e821ad..9b2897bb049 100644 --- a/src/tests/test_utils/common_test_utils/include/common_test_utils/ov_tensor_utils.hpp +++ b/src/tests/test_utils/common_test_utils/include/common_test_utils/ov_tensor_utils.hpp @@ -9,9 +9,28 @@ namespace ov { namespace test { namespace utils { +struct InputGenerateData { + double start_from = 0; + uint32_t range = 10; + int32_t resolution = 1; + int32_t seed = 1; + + InputGenerateData(double _start_from = 0, uint32_t _range = 10, int32_t _resolution = 1, int32_t _seed = 1) + : start_from(_start_from), + range(_range), + resolution(_resolution), + seed(_seed){}; +}; + ov::Tensor create_and_fill_tensor(const ov::element::Type element_type, const ov::Shape& shape, - const uint32_t range = 10, + const InputGenerateData& inGenData = InputGenerateData(0, 10, 1, 1)); + +// Legacy impl for contrig repo +// todo: remove this after dependent repos clean up +ov::Tensor create_and_fill_tensor(const ov::element::Type element_type, + const ov::Shape& shape, + const uint32_t range, const double_t start_from = 0, const int32_t resolution = 1, const int seed = 1); diff --git a/src/tests/test_utils/common_test_utils/src/node_builders/augru_cell.cpp b/src/tests/test_utils/common_test_utils/src/node_builders/augru_cell.cpp index 41bfa327109..0a55d743d08 100644 --- a/src/tests/test_utils/common_test_utils/src/node_builders/augru_cell.cpp +++ b/src/tests/test_utils/common_test_utils/src/node_builders/augru_cell.cpp @@ -54,11 +54,11 @@ std::shared_ptr make_augru(const OutputVector& in, } case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST: case ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST: { + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = in[0].get_shape()[1]; auto seq_lengths_tensor = - ov::test::utils::create_and_fill_tensor(ov::element::i64, - constants[3], - static_cast(in[0].get_shape()[1]), - 0); + ov::test::utils::create_and_fill_tensor(ov::element::i64, constants[3], in_data); seq_lengths = std::make_shared(seq_lengths_tensor); } case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_PARAM: diff --git a/src/tests/test_utils/common_test_utils/src/node_builders/gru_cell.cpp b/src/tests/test_utils/common_test_utils/src/node_builders/gru_cell.cpp index 93d446804af..653a33b358c 100644 --- a/src/tests/test_utils/common_test_utils/src/node_builders/gru_cell.cpp +++ b/src/tests/test_utils/common_test_utils/src/node_builders/gru_cell.cpp @@ -69,11 +69,11 @@ std::shared_ptr make_gru(const OutputVector& in, } case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST: case ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST: { + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = in[0].get_shape()[1]; auto seq_lengths_tensor = - ov::test::utils::create_and_fill_tensor(ov::element::i64, - constants[3], - static_cast(in[0].get_shape()[1]), - 0); + ov::test::utils::create_and_fill_tensor(ov::element::i64, constants[3], in_data); seq_lengths = std::make_shared(seq_lengths_tensor); break; } diff --git a/src/tests/test_utils/common_test_utils/src/node_builders/lstm_cell.cpp b/src/tests/test_utils/common_test_utils/src/node_builders/lstm_cell.cpp index edcb82437b4..74769308477 100644 --- a/src/tests/test_utils/common_test_utils/src/node_builders/lstm_cell.cpp +++ b/src/tests/test_utils/common_test_utils/src/node_builders/lstm_cell.cpp @@ -31,14 +31,16 @@ std::shared_ptr make_lstm(const std::vector>& in, auto B = std::make_shared(b_tensor); if (WRB_range > 0) { - w_tensor = - ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[0], 2 * WRB_range, -WRB_range); + ov::test::utils::InputGenerateData in_data; + in_data.start_from = -WRB_range; + in_data.range = 2 * WRB_range; + w_tensor = ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[0], in_data); W = std::make_shared(w_tensor); - r_tensor = - ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[1], 2 * WRB_range, -WRB_range); + + r_tensor = ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[1], in_data); R = std::make_shared(r_tensor); - b_tensor = - ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[2], 2 * WRB_range, -WRB_range); + + b_tensor = ov::test::utils::create_and_fill_tensor(in[0].get_element_type(), constants[2], in_data); B = std::make_shared(b_tensor); } if (!make_sequence) { @@ -80,11 +82,11 @@ std::shared_ptr make_lstm(const std::vector>& in, } case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST: case ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST: { + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = in[0].get_shape()[1]; auto seq_lengths_tensor = - ov::test::utils::create_and_fill_tensor(ov::element::i64, - constants[3], - static_cast(in[0].get_shape()[1]), - 0); + ov::test::utils::create_and_fill_tensor(ov::element::i64, constants[3], in_data); seq_lengths = std::make_shared(seq_lengths_tensor); break; } diff --git a/src/tests/test_utils/common_test_utils/src/node_builders/rnn_cell.cpp b/src/tests/test_utils/common_test_utils/src/node_builders/rnn_cell.cpp index 77ab22e4e2b..17ac89a81bc 100644 --- a/src/tests/test_utils/common_test_utils/src/node_builders/rnn_cell.cpp +++ b/src/tests/test_utils/common_test_utils/src/node_builders/rnn_cell.cpp @@ -67,11 +67,11 @@ std::shared_ptr make_rnn(const OutputVector& in, } case ov::test::utils::SequenceTestsMode::CONVERT_TO_TI_RAND_SEQ_LEN_CONST: case ov::test::utils::SequenceTestsMode::PURE_SEQ_RAND_SEQ_LEN_CONST: { + ov::test::utils::InputGenerateData in_data; + in_data.start_from = 0; + in_data.range = in[0].get_shape()[1]; auto seq_lengths_tensor = - ov::test::utils::create_and_fill_tensor(ov::element::i64, - constants[3], - static_cast(in[0].get_shape()[1]), - 0); + ov::test::utils::create_and_fill_tensor(ov::element::i64, constants[3], in_data); seq_lengths = std::make_shared(seq_lengths_tensor); break; } diff --git a/src/tests/test_utils/common_test_utils/src/ov_tensor_utils.cpp b/src/tests/test_utils/common_test_utils/src/ov_tensor_utils.cpp index f559e8f9452..b39a53bb296 100644 --- a/src/tests/test_utils/common_test_utils/src/ov_tensor_utils.cpp +++ b/src/tests/test_utils/common_test_utils/src/ov_tensor_utils.cpp @@ -13,44 +13,43 @@ namespace test { namespace utils { ov::Tensor create_and_fill_tensor(const ov::element::Type element_type, const ov::Shape& shape, - const uint32_t range, - const double_t start_from, - const int32_t resolution, - const int seed) { - auto tensor = ov::Tensor{element_type, shape}; -#define CASE(X) \ - case X: \ - fill_data_random(tensor.data::value_type>(), \ - shape_size(shape), \ - range, \ - start_from, \ - resolution, \ - seed); \ + const InputGenerateData& inGenData) { + auto tensor = ov::Tensor(element_type, shape); + +#define CASE(X) \ + case X: \ + fill_data_random(tensor.data>(), \ + shape_size(shape), \ + inGenData.range, \ + inGenData.start_from, \ + inGenData.resolution, \ + inGenData.seed); \ break; + switch (element_type) { - CASE(ov::element::Type_t::boolean) - CASE(ov::element::Type_t::i8) - CASE(ov::element::Type_t::i16) - CASE(ov::element::Type_t::i32) - CASE(ov::element::Type_t::i64) - CASE(ov::element::Type_t::u8) - CASE(ov::element::Type_t::u16) - CASE(ov::element::Type_t::u32) - CASE(ov::element::Type_t::u64) - CASE(ov::element::Type_t::bf16) - CASE(ov::element::Type_t::f16) - CASE(ov::element::Type_t::f32) - CASE(ov::element::Type_t::f64) + CASE(ov::element::boolean) + CASE(ov::element::i8) + CASE(ov::element::i16) + CASE(ov::element::i32) + CASE(ov::element::i64) + CASE(ov::element::u8) + CASE(ov::element::u16) + CASE(ov::element::u32) + CASE(ov::element::u64) + CASE(ov::element::bf16) + CASE(ov::element::f16) + CASE(ov::element::f32) + CASE(ov::element::f64) case ov::element::Type_t::u1: case ov::element::Type_t::i4: case ov::element::Type_t::u4: case ov::element::Type_t::nf4: fill_data_random(static_cast(tensor.data()), tensor.get_byte_size(), - range, - start_from, - resolution, - seed); + inGenData.range, + inGenData.start_from, + inGenData.resolution, + inGenData.seed); break; default: OPENVINO_THROW("Unsupported element type: ", element_type); @@ -59,6 +58,19 @@ ov::Tensor create_and_fill_tensor(const ov::element::Type element_type, return tensor; } +// Legacy impl for contrig repo +// todo: remove this after dependent repos clean up +ov::Tensor create_and_fill_tensor(const ov::element::Type element_type, + const ov::Shape& shape, + const uint32_t range, + const double_t start_from, + const int32_t resolution, + const int seed) { + return create_and_fill_tensor(element_type, + shape, + ov::test::utils::InputGenerateData(start_from, range, resolution, seed)); +} + ov::Tensor create_and_fill_tensor_unique_sequence(const ov::element::Type element_type, const ov::Shape& shape, const int32_t start_from, diff --git a/src/tests/test_utils/common_test_utils/src/postgres_helpers.cpp b/src/tests/test_utils/common_test_utils/src/postgres_helpers.cpp index 6a76b1aedcb..74861d36e16 100644 --- a/src/tests/test_utils/common_test_utils/src/postgres_helpers.cpp +++ b/src/tests/test_utils/common_test_utils/src/postgres_helpers.cpp @@ -459,7 +459,7 @@ std::string get_hostname(void) { #endif } return cHostName; -} +} // namespace PostgreSQLHelpers void add_pair(std::map& keyValues, const std::string& key, const std::string& value) { size_t dPos; diff --git a/src/tests/test_utils/common_test_utils/src/postgres_link.cpp b/src/tests/test_utils/common_test_utils/src/postgres_link.cpp index 30b5a1f3ec1..a6403abefe6 100644 --- a/src/tests/test_utils/common_test_utils/src/postgres_link.cpp +++ b/src/tests/test_utils/common_test_utils/src/postgres_link.cpp @@ -474,7 +474,7 @@ class PostgreSQLEventListener : public ::testing::EmptyTestEventListener { std::stringstream sstr; sstr << "DELETE FROM test_results_temp WHERE tr_id=" << this->testId; auto pgresult = connectionKeeper->query(sstr.str().c_str(), PGRES_COMMAND_OK); - CHECK_PGRESULT(pgresult, "Cannot remove waste results", return); + CHECK_PGRESULT(pgresult, "Cannot remove waste results", return ); this->testId = 0; testDictionary.clear(); @@ -557,7 +557,7 @@ class PostgreSQLEventListener : public ::testing::EmptyTestEventListener { << ", run_count=" << test_suite.test_to_run_count() << ", total_count=" << test_suite.total_test_count() << " WHERE sr_id=" << this->testSuiteId; auto pgresult = connectionKeeper->query(sstr.str().c_str(), PGRES_COMMAND_OK); - CHECK_PGRESULT(pgresult, "Cannot update test suite results", return); + CHECK_PGRESULT(pgresult, "Cannot update test suite results", return ); this->testSuiteId = 0; if (reportingLevel == REPORT_LVL_FAST) { @@ -641,13 +641,13 @@ class PostgreSQLEventListener : public ::testing::EmptyTestEventListener { std::stringstream sstr; sstr << "UPDATE runs SET end_time=NOW() WHERE run_id=" << this->testRunId << " AND end_timequery(sstr.str().c_str(), PGRES_COMMAND_OK); - CHECK_PGRESULT(pgresult, "Cannot update run finish info", return); + CHECK_PGRESULT(pgresult, "Cannot update run finish info", return ); sstr.str(""); sstr.clear(); sstr << "UPDATE sessions SET end_time=NOW() WHERE session_id=" << this->sessionId << " AND end_timequery(sstr.str().c_str(), PGRES_COMMAND_OK); - CHECK_PGRESULT(pgresult, "Cannot update session finish info", return); + CHECK_PGRESULT(pgresult, "Cannot update session finish info", return ); } /* Prohobit creation outsize of class, need to make a Singleton */