move test from cpu plugin to shared

Author: bopeng1234

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/conversion.cpp

@@ -282,20 +282,6 @@ void ConvertToBooleanCPULayerTest::generate_inputs(const std::vector<ov::Shape>&
     inputs.insert({funcInputs[0].get_node_shared_ptr(), tensor});
 }
 
-void ConvertI32ToU8CPULayerTest::validate_out_prc() const {
-    if (inPrc != ov::element::i32 || outPrc != ov::element::u8)
-        FAIL() << "ConvertI32ToU8CPULayerTest supports only i32->u8 conversion.";
-}
-
-void ConvertI32ToU8CPULayerTest::generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) {
-    inputs.clear();
-    const auto& funcInputs = function->inputs();
-    const auto& funcInput = funcInputs[0];
-    ov::Tensor tensor(funcInput.get_element_type(), targetInputStaticShapes[0]);
-    ov::test::utils::fill_data_random(tensor.data<int32_t>(), tensor.get_size(), 1024, -512);
-    inputs.insert({funcInput.get_node_shared_ptr(), tensor});
-}
-
 TEST_P(ConvertCPULayerTest, CompareWithRefs) {
     run();
     CheckPluginRelatedResults(compiledModel, std::set<std::string>{"Convert", "Subgraph"});
@@ -309,11 +295,6 @@ TEST_P(ConvertToBooleanCPULayerTest, CompareWithRefs) {
     CheckPluginRelatedResults(compiledModel, std::set<std::string>{});
 }
 
-TEST_P(ConvertI32ToU8CPULayerTest, CompareWithRefs) {
-    run();
-    CheckPluginRelatedResults(compiledModel, std::set<std::string>{"Convert", "Subgraph"});
-}
-
 namespace Conversion {
 
 const std::vector<InputShape>& inShapes_4D_static() {

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/conversion.hpp

@@ -43,12 +43,6 @@ class ConvertToBooleanCPULayerTest : public ConvertCPULayerTest {
     void validate_out_prc() const override;
 };
 
-class ConvertI32ToU8CPULayerTest : public ConvertCPULayerTest {
-protected:
-    void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override;
-    void validate_out_prc() const override;
-};
-
 namespace Conversion {
 const std::vector<InputShape>& inShapes_4D_static();
 const std::vector<InputShape>& inShapes_4D_dynamic();

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/conversion.cpp

@@ -67,15 +67,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_ConvertCPULayerTest_BOOL_Dynamic, ConvertToBoolea
                                 ::testing::Values(CPUSpecificParams({nchw}, {nchw}, {}, {}))),
                         ConvertToBooleanCPULayerTest::getTestCaseName);
 
-INSTANTIATE_TEST_SUITE_P(smoke_ConvertCPULayerTest_I32ToU8_Static, ConvertI32ToU8CPULayerTest,
-                         ::testing::Combine(
-                                ::testing::ValuesIn(inShapes_4D_static()),
-                                ::testing::Values(ov::element::i32),
-                                ::testing::Values(ov::element::u8),
-                                ::testing::Values(ov::test::SpecialValue::none),
-                                ::testing::Values(CPUSpecificParams({nchw}, {nchw}, {}, {}))),
-                         ConvertI32ToU8CPULayerTest::getTestCaseName);
-
 }  // namespace
 }  // namespace Conversion
 }  // namespace test

src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/conversion.cpp

@@ -9,6 +9,7 @@
 
 namespace {
 using ov::test::ConversionLayerTest;
+using ov::test::ConversionSpecifyInputLayerTest;
 
 const std::vector<ov::test::utils::ConversionTypes> conversionOpTypes = {
     ov::test::utils::ConversionTypes::CONVERT,
@@ -79,4 +80,13 @@ INSTANTIATE_TEST_SUITE_P(smoke_ConversionFromF8LayerTest,
                                             ::testing::Values(ov::test::utils::DEVICE_CPU)),
                          ConversionLayerTest::getTestCaseName);
 
+INSTANTIATE_TEST_SUITE_P(smoke_ConversionI32ToU8LayerTest,
+                         ConversionSpecifyInputLayerTest,
+                         ::testing::Combine(::testing::Values(conversionOpTypes[0]),
+                                            ::testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes)),
+                                            ::testing::Values(ov::element::i32),
+                                            ::testing::Values(ov::element::u8),
+                                            ::testing::Values(ov::test::utils::DEVICE_CPU)),
+                         ConversionSpecifyInputLayerTest::getTestCaseName);
+
 }  // namespace

src/tests/functional/plugin/shared/include/shared_test_classes/single_op/conversion.hpp

@@ -26,5 +26,11 @@ class ConversionLayerTest : public testing::WithParamInterface<ConversionParamsT
 protected:
     void SetUp() override;
 };
+
+class ConversionSpecifyInputLayerTest : public ConversionLayerTest {
+protected:
+    void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override;
+};
+
 }  // namespace test
 }  // namespace ov

src/tests/functional/plugin/shared/include/single_op_tests/conversion.hpp

@@ -11,5 +11,8 @@ namespace test {
 TEST_P(ConversionLayerTest, Inference) {
     run();
 };
+TEST_P(ConversionSpecifyInputLayerTest, Inference) {
+    run();
+};
 }  // namespace test
 }  // namespace ov

src/tests/functional/plugin/shared/src/single_op/conversion.cpp

@@ -3,6 +3,8 @@
 //
 
 #include "shared_test_classes/single_op/conversion.hpp"
+
+#include "common_test_utils/data_utils.hpp"
 #include "openvino/op/convert.hpp"
 #include "openvino/op/convert_like.hpp"
 
@@ -57,5 +59,21 @@ void ConversionLayerTest::SetUp() {
     auto result = std::make_shared<ov::op::v0::Result>(conversion);
     function = std::make_shared<ov::Model>(result, params, "Conversion");
 }
+
+void ConversionSpecifyInputLayerTest::generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) {
+    const auto& [conversion_type, shapes, input_type, convert_type, _targetDevice] = GetParam();
+    if (input_type != ov::element::i32 || convert_type != ov::element::u8) {
+        SubgraphBaseTest::generate_inputs(targetInputStaticShapes);
+        return;
+    }
+
+    inputs.clear();
+    const auto& funcInputs = function->inputs();
+    const auto& funcInput = funcInputs[0];
+    ov::Tensor tensor(funcInput.get_element_type(), targetInputStaticShapes[0]);
+    ov::test::utils::fill_data_random(tensor.data<int32_t>(), tensor.get_size(), 1024, -512);
+    inputs.insert({funcInput.get_node_shared_ptr(), tensor});
+}
+
 }  // namespace test
 }  // namespace ov