update file type and add comment

Author: DanLiu2Intel

src/core/tests/pass/serialization/serialize.cpp

@@ -789,10 +789,10 @@ class UndefinedTypeDynamicTypeSerializationTests : public ::testing::Test {
 </net>
 )V0G0N";
 
-    std::string m_dynamic_type_out_xml_path;
-    std::string m_dynamic_type_out_bin_path;
-    std::string m_undefined_type_out_xml_path;
-    std::string m_undefined_type_out_bin_path;
+    std::filesystem::path m_dynamic_type_out_xml_path;
+    std::filesystem::path m_dynamic_type_out_bin_path;
+    std::filesystem::path m_undefined_type_out_xml_path;
+    std::filesystem::path m_undefined_type_out_bin_path;
 
     void SetUp() override {
         std::string filePrefix = ov::test::utils::generateTestFilePrefix();
@@ -803,15 +803,26 @@ class UndefinedTypeDynamicTypeSerializationTests : public ::testing::Test {
     }
 
     void TearDown() override {
-        std::remove(m_undefined_type_out_xml_path.c_str());
-        std::remove(m_undefined_type_out_bin_path.c_str());
-        std::remove(m_dynamic_type_out_xml_path.c_str());
-        std::remove(m_dynamic_type_out_bin_path.c_str());
+        if (std::filesystem::exists(m_undefined_type_out_xml_path)) {
+            std::filesystem::remove(m_undefined_type_out_xml_path);
+        }
+
+        if (std::filesystem::exists(m_undefined_type_out_bin_path)) {
+            std::filesystem::remove(m_undefined_type_out_bin_path);
+        }
+
+        if (std::filesystem::exists(m_dynamic_type_out_xml_path)) {
+            std::filesystem::remove(m_dynamic_type_out_xml_path);
+        }
+
+        if (std::filesystem::exists(m_dynamic_type_out_bin_path)) {
+            std::filesystem::remove(m_dynamic_type_out_bin_path);
+        }
     }
 
-    bool files_equal(const std::string& file_path1, const std::string& file_path2) {
-        std::ifstream xml_dynamic(file_path1, std::ios::binary);
-        std::ifstream xml_undefined(file_path2, std::ios::binary);
+    bool files_equal(const std::filesystem::path& file_path1, const std::filesystem::path& file_path2) {
+        std::ifstream xml_dynamic(file_path1.string(), std::ios::binary);
+        std::ifstream xml_undefined(file_path2.string(), std::ios::binary);
 
         if (!xml_dynamic.good() || !xml_undefined.good()) {
             return false;
@@ -825,18 +836,18 @@ class UndefinedTypeDynamicTypeSerializationTests : public ::testing::Test {
 
 // check stringstream serialize
 TEST_F(UndefinedTypeDynamicTypeSerializationTests, compare_dynamic_type_undefined_type_serialization_stringstream) {
-    std::stringstream dynamicTypeModelXmlStream, undefinedTypeModelXmlStream, dynamicTypeModelBinStream,
-        undefinedTypeModelBinStream;
+    std::stringstream dynamicXmlStream, undefinedXmlStream, dynamicBinStream,
+        undefinedBinStream;
 
     // Test whether the serialization results of the two models are the same
     auto dynamicTypeModel = ov::test::readModel(dynamic_type_ir);
     auto undefinedTypeModel = ov::test::readModel(undefined_type_ir);
 
     // compile the serialized models with stringstream type
-    ov::pass::Serialize(dynamicTypeModelXmlStream, dynamicTypeModelBinStream).run_on_model(dynamicTypeModel);
-    ov::pass::Serialize(undefinedTypeModelXmlStream, undefinedTypeModelBinStream).run_on_model(undefinedTypeModel);
+    ov::pass::Serialize(dynamicXmlStream, dynamicBinStream).run_on_model(dynamicTypeModel);
+    ov::pass::Serialize(undefinedXmlStream, undefinedBinStream).run_on_model(undefinedTypeModel);
 
-    ASSERT_EQ(dynamicTypeModelXmlStream.str(), undefinedTypeModelXmlStream.str())
+    ASSERT_EQ(dynamicXmlStream.str(), undefinedXmlStream.str())
         << "Serialized XML streams are different: dynamic type vs undefined type";
 }
 

src/plugins/intel_npu/tests/functional/behavior/compile_and_infer_different_element_type.hpp

@@ -2,27 +2,28 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <string>
+#include <common_test_utils/ov_tensor_utils.hpp>
 #include <sstream>
+#include <string>
 #include <vector>
 
-#include "shared_test_classes/base/ov_behavior_test_utils.hpp"
-#include <common_test_utils/ov_tensor_utils.hpp>
+#include "openvino/opsets/opset6.hpp"
 #include "openvino/pass/manager.hpp"
 #include "openvino/pass/serialize.hpp"
-#include "openvino/opsets/opset6.hpp"
+#include "shared_test_classes/base/ov_behavior_test_utils.hpp"
 namespace ov {
 namespace test {
 namespace behavior {
 
-using InferRequestElementTypeParams = std::tuple<
-        std::string,                                                       // Device name
-        ov::AnyMap                                                         // Config
->;
+using InferRequestElementTypeParams = std::tuple<std::string,  // Device name
+                                                 ov::AnyMap    // Config
+                                                 >;
 
+// These tests are required by the NPU plugin to verify the compatibility of undefined type and dynamic type during
+// compilation and inference on different NPU drivers, hence they are kept here. Compared to test in serialize it
+// includes an additional comparison of inference results.
 class InferRequestElementTypeTests : public testing::WithParamInterface<InferRequestElementTypeParams>,
-                                   public OVInferRequestTestBase  {
-
+                                     public OVInferRequestTestBase {
 public:
     static std::string getTestCaseName(testing::TestParamInfo<InferRequestElementTypeParams> obj) {
         std::string target_device;
@@ -56,8 +57,8 @@ class InferRequestElementTypeTests : public testing::WithParamInterface<InferReq
     ov::AnyMap configuration;
 };
 
-
-bool InferRequestElementTypeTests::compareTensorOutputs(const ov::Tensor& dynamicInferenceOutput, const ov::Tensor& undefinedInferenceOutput) {
+bool InferRequestElementTypeTests::compareTensorOutputs(const ov::Tensor& dynamicInferenceOutput,
+                                                        const ov::Tensor& undefinedInferenceOutput) {
     const auto dynamicShape = dynamicInferenceOutput.get_shape();
     const auto undefinedShape = undefinedInferenceOutput.get_shape();
 
@@ -83,7 +84,8 @@ bool InferRequestElementTypeTests::compareTensorOutputs(const ov::Tensor& dynami
     return true;
 }
 
-// Test whether the serialization and inference results of the dynamic type model and the undefined type model are the same
+// Test whether the serialization and inference results of the dynamic type model and the undefined type model are the
+// same
 TEST_P(InferRequestElementTypeTests, CompareDynamicAndUndefinedTypeNetwork) {
     // Skip test according to plugin specific disabledTestPatterns() (if any)
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
@@ -282,7 +284,8 @@ TEST_P(InferRequestElementTypeTests, CompareDynamicAndUndefinedTypeNetwork) {
 </net>
 )V0G0N";
 
-    std::stringstream dynamicTypeModelXmlStream, undefinedTypeModelXmlStream, dynamicTypeModelBinStream, undefinedTypeModelBinStream;
+    std::stringstream dynamicTypeModelXmlStream, undefinedTypeModelXmlStream, dynamicTypeModelBinStream,
+        undefinedTypeModelBinStream;
 
     // Test whether the serialization results of the two models are the same
     auto dynamicTypeModel = ie->read_model(dynamicTypeModelXmlString, ov::Tensor());