diff --git a/idl_tool_2/test/unittest/BUILD.gn b/idl_tool_2/test/unittest/BUILD.gn
index 2ad240e1a4ea3f5df221d4dd44374522fb369539..c51fd6dbe10b5718424ac5de8b6fb97c51483246 100644
--- a/idl_tool_2/test/unittest/BUILD.gn
+++ b/idl_tool_2/test/unittest/BUILD.gn
@@ -74,6 +74,8 @@ ohos_unittest("SaTypeEmitterTest") {
   sources = [ "./src/sa_type_emitter_test.cpp" ]
   sources += common_sources
 
+  defines = [ "IDLTOOL_GTEST" ]
+
   deps = []
 
   external_deps = [ "c_utils:utils" ]
diff --git a/idl_tool_2/test/unittest/src/sa_type_emitter_test.cpp b/idl_tool_2/test/unittest/src/sa_type_emitter_test.cpp
index 7d4bda3358f00326e9375da97d5528d7fc321e70..a7dd21ee604846f00d5d172e3aeb147d66ce1bee 100644
--- a/idl_tool_2/test/unittest/src/sa_type_emitter_test.cpp
+++ b/idl_tool_2/test/unittest/src/sa_type_emitter_test.cpp
@@ -14,8 +14,30 @@
  */
 
 #include "sa_type_emitter_test.h"
+
+#ifdef IDLTOOL_GTEST
+#define private   public
+#define protected public
+#endif
 #include "codegen/SA/type/sa_fd_type_emitter.h"
 #include "codegen/SA/type/sa_fdsan_type_emitter.h"
+#include "codegen/SA/type/sa_cstring_type_emitter.h"
+#include "codegen/SA/type/sa_orderedmap_type_emitter.h"
+#include "codegen/SA/type/sa_array_type_emitter.h"
+
+#include "codegen/SA/type/sa_boolean_type_emitter.h"
+#include "codegen/SA/type/sa_byte_type_emitter.h"
+#include "codegen/SA/type/sa_char_type_emitter.h"
+#include "codegen/SA/type/sa_double_type_emitter.h"
+#include "codegen/SA/type/sa_enum_type_emitter.h"
+#include "codegen/SA/type/sa_float_type_emitter.h"
+
+#include "codegen/SA/type/sa_map_type_emitter.h"
+
+
+#include "codegen/SA/type/sa_long_type_emitter.h"
+#include "codegen/SA/type/sa_int_type_emitter.h"
+#include "codegen/SA/type/sa_seq_type_emitter.h"
 
 using namespace testing;
 using namespace testing::ext;
@@ -39,11 +61,12 @@ void SaTypeEmitterTest::TearDown() {}
  */
 HWTEST_F(SaTypeEmitterTest, SaFdTypeEmitterTest_001, Level1)
 {
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdTypeEmitterTest_001, TestSize.Level1";
     SaFdTypeEmitter emitter;
     emitter.logOn_ = true;
     emitter.isProxy = false;
     std::string expectedCode =
-        "if (!parcelWriteFileDescriptor(fd)) {\n"
+        "if (!parcel.WriteFileDescriptor(fd)) {\n"
         "    HiLog::Error(LABEL, \"Write [fd] failed!\");\n"
         "    if (fd >= 0) {\n"
         "        close(fd);\n"
@@ -51,7 +74,7 @@ HWTEST_F(SaTypeEmitterTest, SaFdTypeEmitterTest_001, Level1)
         "    return ERR_INVALID_DATA;\n"
         "}\n";
     StringBuilder sb;
-    emitter.EmitCppWriteVar("parcel", "fd", sb, "");
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
     EXPECT_EQ(sb.ToString(), expectedCode);
 }
 
@@ -63,33 +86,127 @@ HWTEST_F(SaTypeEmitterTest, SaFdTypeEmitterTest_001, Level1)
  */
 HWTEST_F(SaTypeEmitterTest, SaFdTypeEmitterTest_002, Level1)
 {
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdTypeEmitterTest_002, TestSize.Level1";
     SaFdTypeEmitter emitter;
     emitter.logOn_ = true;
     emitter.isProxy = true;
     std::string expectedCode =
-        "if (!parcelWriteFileDescriptor(fd)) {\n"
+        "if (!parcel.WriteFileDescriptor(fd)) {\n"
         "    HiLog::Error(LABEL, \"Write [fd] failed!\");\n"
         "    return ERR_INVALID_DATA;\n"
         "}\n";
     StringBuilder sb;
-    emitter.EmitCppWriteVar("parcel", "fd", sb, "");
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
     EXPECT_EQ(sb.ToString(), expectedCode);
 }
 
+/*
+ * @tc.name: SaFdTypeEmitterTest_003
+ * @tc.desc: test SaFdTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaFdTypeEmitterTest_003, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdTypeEmitterTest_003, TestSize.Level1";
+    SaFdTypeEmitter emitter;
+    emitter.logOn_ = false;
+    emitter.isProxy = false;
+    std::string expectedCode =
+        "if (!parcel.WriteFileDescriptor(fd)) {\n"
+        "    if (fd >= 0) {\n"
+        "        close(fd);\n"
+        "    }\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaFdTypeEmitterTest_004
+ * @tc.desc: test SaFdTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaFdTypeEmitterTest_004, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdTypeEmitterTest_004, TestSize.Level1";
+    SaFdTypeEmitter emitter;
+    emitter.logOn_ = false;
+    emitter.isProxy = true;
+    std::string expectedCode =
+        "if (!parcel.WriteFileDescriptor(fd)) {\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaFdTypeEmitterTest_005
+ * @tc.desc: test SaFdTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaFdTypeEmitterTest_005, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdTypeEmitterTest_005, TestSize.Level1";
+    SaFdTypeEmitter emitter;
+    std::string type = emitter.EmitCppType(TypeMode::NO_MODE);
+    EXPECT_EQ(type, "int");
+    type = emitter.EmitCppType(TypeMode::PARAM_IN);
+    EXPECT_EQ(type, "int");
+    type = emitter.EmitCppType(TypeMode::LOCAL_VAR);
+    EXPECT_EQ(type, "int");
+    type = emitter.EmitCppType(TypeMode::PARAM_INOUT);
+    EXPECT_EQ(type, "int&");
+    type = emitter.EmitCppType(TypeMode::PARAM_OUT);
+    EXPECT_EQ(type, "int&");
+    type = emitter.EmitCppType(static_cast<TypeMode>(9));
+    EXPECT_EQ(type, "unknown type");
+}
+
+/*
+ * @tc.name: SaFdTypeEmitterTest_006
+ * @tc.desc: test SaFdTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaFdTypeEmitterTest_006, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdTypeEmitterTest_006, TestSize.Level1";
+    SaFdTypeEmitter emitter;
+    std::string expectedCode =
+        "int fd = parcel.ReadFileDescriptor();\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    std::string expectedCode2 =
+        "fd = parcel.ReadFileDescriptor();\n";
+    StringBuilder sb2;
+    emitter.EmitCppReadVar("parcel.", "fd", sb2, "", false);
+    EXPECT_EQ(sb2.ToString(), expectedCode2);
+}
+
 /*
  * @tc.name: SaFdSanTypeEmitterTest_001
- * @tc.desc: test SaFdSanTypeEmitter EmitCppWriteVar stub
+ * @tc.desc: test SaFdSanTypeEmitter EmitCppWriteVar
  * @tc.type: FUNC
  * @tc.require:
  */
 HWTEST_F(SaTypeEmitterTest, SaFdSanTypeEmitterTest_001, Level1)
 {
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdSanTypeEmitterTest_001, TestSize.Level1";
     SaFdSanTypeEmitter emitter;
     emitter.logOn_ = true;
     emitter.isProxy = false;
     emitter.domainId_ = "testDomainId";
     std::string expectedCode =
-        "if (!parcelWriteFileDescriptor(fd)) {\n"
+        "if (!parcel.WriteFileDescriptor(fd)) {\n"
         "    HiLog::Error(LABEL, \"Write [fd] failed!\");\n"
         "    if (fd >= 0) {\n"
         "        fdsan_close_with_tag(fd, testDomainId);\n"
@@ -97,7 +214,7 @@ HWTEST_F(SaTypeEmitterTest, SaFdSanTypeEmitterTest_001, Level1)
         "    return ERR_INVALID_DATA;\n"
         "}\n";
     StringBuilder sb;
-    emitter.EmitCppWriteVar("parcel", "fd", sb, "");
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
     EXPECT_EQ(sb.ToString(), expectedCode);
 }
 
@@ -109,17 +226,716 @@ HWTEST_F(SaTypeEmitterTest, SaFdSanTypeEmitterTest_001, Level1)
  */
 HWTEST_F(SaTypeEmitterTest, SaFdSanTypeEmitterTest_002, Level1)
 {
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdSanTypeEmitterTest_002, TestSize.Level1";
     SaFdSanTypeEmitter emitter;
     emitter.logOn_ = true;
     emitter.isProxy = true;
     emitter.domainId_ = "testDomainId";
     std::string expectedCode =
-        "if (!parcelWriteFileDescriptor(fd)) {\n"
+        "if (!parcel.WriteFileDescriptor(fd)) {\n"
         "    HiLog::Error(LABEL, \"Write [fd] failed!\");\n"
         "    return ERR_INVALID_DATA;\n"
         "}\n";
     StringBuilder sb;
-    emitter.EmitCppWriteVar("parcel", "fd", sb, "");
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaFdSanTypeEmitterTest_003
+ * @tc.desc: test SaFdSanTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaFdSanTypeEmitterTest_003, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdSanTypeEmitterTest_003, TestSize.Level1";
+    SaFdSanTypeEmitter emitter;
+    emitter.logOn_ = false;
+    emitter.isProxy = false;
+    emitter.domainId_ = "testDomainId";
+    std::string expectedCode =
+        "if (!parcel.WriteFileDescriptor(fd)) {\n"
+        "    if (fd >= 0) {\n"
+        "        fdsan_close_with_tag(fd, testDomainId);\n"
+        "    }\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaFdSanTypeEmitterTest_004
+ * @tc.desc: test SaFdSanTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaFdSanTypeEmitterTest_004, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdSanTypeEmitterTest_004, TestSize.Level1";
+    SaFdSanTypeEmitter emitter;
+    emitter.logOn_ = false;
+    emitter.isProxy = true;
+    emitter.domainId_ = "testDomainId";
+    std::string expectedCode =
+        "if (!parcel.WriteFileDescriptor(fd)) {\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaFdSanTypeEmitterTest_005
+ * @tc.desc: test SaFdSanTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaFdSanTypeEmitterTest_005, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdSanTypeEmitterTest_005, TestSize.Level1";
+    SaFdSanTypeEmitter emitter;
+    std::string type = emitter.EmitCppType(TypeMode::NO_MODE);
+    EXPECT_EQ(type, "int");
+    type = emitter.EmitCppType(TypeMode::PARAM_IN);
+    EXPECT_EQ(type, "int");
+    type = emitter.EmitCppType(TypeMode::LOCAL_VAR);
+    EXPECT_EQ(type, "int");
+    type = emitter.EmitCppType(TypeMode::PARAM_INOUT);
+    EXPECT_EQ(type, "int&");
+    type = emitter.EmitCppType(TypeMode::PARAM_OUT);
+    EXPECT_EQ(type, "int&");
+    type = emitter.EmitCppType(static_cast<TypeMode>(9));
+    EXPECT_EQ(type, "unknown type");
+}
+
+/*
+ * @tc.name: SaFdSanTypeEmitterTest_006
+ * @tc.desc: test SaFdSanTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaFdSanTypeEmitterTest_006, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaFdSanTypeEmitterTest_006, TestSize.Level1";
+    SaFdSanTypeEmitter emitter;
+    std::string expectedCode =
+        "int fd = parcel.ReadFileDescriptor();\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    std::string expectedCode2 =
+        "fd = parcel.ReadFileDescriptor();\n";
+    StringBuilder sb2;
+    emitter.EmitCppReadVar("parcel.", "fd", sb2, "", false);
+    EXPECT_EQ(sb2.ToString(), expectedCode2);
+}
+
+/*
+ * @tc.name: SaCStringTypeEmitterTest_001
+ * @tc.desc: test SaCStringTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaCStringTypeEmitterTest_001, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaCStringTypeEmitterTest_001, TestSize.Level1";
+    SaCStringTypeEmitter emitter;
+    emitter.logOn_ = true;
+    std::string expectedCode =
+        "if (!parcel.WriteCString(fd)) {\n"
+        "    HiLog::Error(LABEL, \"Write [fd] failed!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaCStringTypeEmitterTest_002
+ * @tc.desc: test SaCStringTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaCStringTypeEmitterTest_002, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaCStringTypeEmitterTest_002, TestSize.Level1";
+    SaCStringTypeEmitter emitter;
+    emitter.logOn_ = false;
+    std::string expectedCode =
+        "if (!parcel.WriteCString(fd)) {\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaCStringTypeEmitterTest_003
+ * @tc.desc: test SaFdTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaCStringTypeEmitterTest_003, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaCStringTypeEmitterTest_003, TestSize.Level1";
+    SaCStringTypeEmitter emitter;
+    std::string type = emitter.EmitCppType(TypeMode::NO_MODE);
+    EXPECT_EQ(type, "const char *");
+    type = emitter.EmitCppType(TypeMode::LOCAL_VAR);
+    EXPECT_EQ(type, "const char *");
+    type = emitter.EmitCppType(TypeMode::PARAM_IN);
+    EXPECT_EQ(type, "const char *");
+    type = emitter.EmitCppType(TypeMode::PARAM_INOUT);
+    EXPECT_EQ(type, "const char *");
+    type = emitter.EmitCppType(TypeMode::PARAM_OUT);
+    EXPECT_EQ(type, "const char *");
+    type = emitter.EmitCppType(static_cast<TypeMode>(9));
+    EXPECT_EQ(type, "unknown type");
+}
+
+/*
+ * @tc.name: SaCStringTypeEmitterTest_004
+ * @tc.desc: test SaFdTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaCStringTypeEmitterTest_004, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaCStringTypeEmitterTest_004, TestSize.Level1";
+    SaCStringTypeEmitter emitter;
+    std::string expectedCode =
+        "const char * fd = parcel.ReadCString();\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    std::string expectedCode2 =
+        "fd = parcel.ReadCString();\n";
+    StringBuilder sb2;
+    emitter.EmitCppReadVar("parcel.", "fd", sb2, "", false);
+    EXPECT_EQ(sb2.ToString(), expectedCode2);
+}
+
+/*
+ * @tc.name: SaOrderedMapTypeEmitterTest_001
+ * @tc.desc: test SaOrderedMapTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaOrderedMapTypeEmitterTest_001, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaOrderedMapTypeEmitterTest_001, TestSize.Level1";
+    SaOrderedMapTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCount_ = 0;
+    AutoPtr<SaLongTypeEmitter> keyEmitter = new SaLongTypeEmitter();
+    AutoPtr<SaLongTypeEmitter> valueEmitter = new SaLongTypeEmitter();
+    emitter.SetKeyEmitter(keyEmitter);
+    emitter.SetValueEmitter(valueEmitter);
+    std::string expectedCode =
+        "if (fd.size() > static_cast<size_t>(MAP_MAX_SIZE)) {\n"
+        "    HiLog::Error(LABEL, \"The map size exceeds the security limit!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "\n"
+        "parcel.WriteInt32(fd.size());\n"
+        "for (auto it0 = fd.begin(); it0 != fd.end(); ++it0) {\n"
+        "    if (!parcel.WriteInt64((it0->first))) {\n"
+        "        HiLog::Error(LABEL, \"Write [(it0->first)] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "    if (!parcel.WriteInt64((it0->second))) {\n"
+        "        HiLog::Error(LABEL, \"Write [(it0->second)] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
     EXPECT_EQ(sb.ToString(), expectedCode);
 }
+
+/*
+ * @tc.name: SaOrderedMapTypeEmitterTest_002
+ * @tc.desc: test SaOrderedMapTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaOrderedMapTypeEmitterTest_002, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaOrderedMapTypeEmitterTest_002, TestSize.Level1";
+    SaOrderedMapTypeEmitter emitter;
+    emitter.logOn_ = false;
+    emitter.circleCount_ = 0;
+    AutoPtr<SaLongTypeEmitter> keyEmitter = new SaLongTypeEmitter();
+    AutoPtr<SaLongTypeEmitter> valueEmitter = new SaLongTypeEmitter();
+    emitter.SetKeyEmitter(keyEmitter);
+    emitter.SetValueEmitter(valueEmitter);
+    std::string expectedCode =
+        "if (fd.size() > static_cast<size_t>(MAP_MAX_SIZE)) {\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "\n"
+        "parcel.WriteInt32(fd.size());\n"
+        "for (auto it0 = fd.begin(); it0 != fd.end(); ++it0) {\n"
+        "    if (!parcel.WriteInt64((it0->first))) {\n"
+        "       HiLog::Error(LABEL, \"Write [(it0->first)] failed!\");\n"
+        "       return ERR_INVALID_DATA;\n"
+        "   }\n"
+        "   if (!parcel.WriteInt64((it0->second))) {\n"
+        "       HiLog::Error(LABEL, \"Write [(it0->second)] failed!\");\n"
+        "       return ERR_INVALID_DATA;\n"
+        "   }\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaOrderedMapTypeEmitterTest_003
+ * @tc.desc: test SaOrderedMapTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaOrderedMapTypeEmitterTest_003, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaOrderedMapTypeEmitterTest_003, TestSize.Level1";
+    SaOrderedMapTypeEmitter emitter;
+    AutoPtr<SaLongTypeEmitter> keyEmitter = new SaLongTypeEmitter();
+    AutoPtr<SaLongTypeEmitter> valueEmitter = new SaLongTypeEmitter();
+    emitter.SetKeyEmitter(keyEmitter);
+    emitter.SetValueEmitter(valueEmitter);
+    std::string type = emitter.EmitCppType(TypeMode::NO_MODE);
+    EXPECT_EQ(type, "std::map<int64_t, int32_t>");
+    type = emitter.EmitCppType(TypeMode::LOCAL_VAR);
+    EXPECT_EQ(type, "std::map<int64_t, int32_t>");
+    type = emitter.EmitCppType(TypeMode::PARAM_IN);
+    EXPECT_EQ(type, "const std::map<int64_t, int32_t>&");
+    type = emitter.EmitCppType(TypeMode::PARAM_OUT);
+    EXPECT_EQ(type, "std::map<int64_t, int32_t>>&");
+    type = emitter.EmitCppType(TypeMode::PARAM_INOUT);
+    EXPECT_EQ(type, "std::map<int64_t, int32_t>>&");
+    type = emitter.EmitCppType(static_cast<TypeMode>(9));
+    EXPECT_EQ(type, "unknown type");
+}
+
+/*
+ * @tc.name: SaOrderedMapTypeEmitterTest_004
+ * @tc.desc: test SaOrderedMapTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaTypeEmitterTest, SaOrderedMapTypeEmitterTest_004, Level1)
+{
+    GTEST_LOG_(INFO) << "SaTypeEmitterTest, SaOrderedMapTypeEmitterTest_004, TestSize.Level1";
+    SaOrderedMapTypeEmitter emitter;
+    emitter.circleCount_ = 0;
+    AutoPtr<SaLongTypeEmitter> keyEmitter = new SaLongTypeEmitter();
+    AutoPtr<SaLongTypeEmitter> valueEmitter = new SaLongTypeEmitter();
+    emitter.SetKeyEmitter(keyEmitter);
+    emitter.SetValueEmitter(valueEmitter);
+    emitter.keyEmitter_->SetTypeName("long");
+    emitter.valueEmitter_->SetTypeName("long");
+    emitter.keyEmitter_->logOn_ = true;
+    emitter.valueEmitter_->logOn_ = true;
+    std::string expectedCode =
+        "std::map<long, long> fd.txt;\n"
+        "int32_t txtSize = parcel.ReadInt32();\n"
+        "for (int32_t i0 = 0; i0 < txtSize; ++i0) {\n"
+        "    std::unique_ptr<long> key0(parcel.ReadParcelable<long>());\n"
+        "    if (!key0) {\n"
+        "        HiLog::Error(LABEL, \"Read [long] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n\n"
+        "    std::unique_ptr<long> value0(parcel.ReadParcelable<long>());\n"
+        "    if (!value0) {\n"
+        "        HiLog::Error(LABEL, \"Read [long] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n\n"
+        "    fd.txt[*key0] = *value0;\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd.txt", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    std::string expectedCode2 =
+        "int32_t txtSize = parcel.ReadInt32();\n"
+        "for (int32_t i0 = 0; i0 < txtSize; ++i0) {\n"
+        "    std::unique_ptr<long> key0Info(parcel.ReadParcelable<long>());\n",
+        "    if (key0Info != nullptr) {\n"
+        "    key0 = *key0Info;\n"
+        "    }\n\n"
+        "    std::unique_ptr<long> value0Info(parcel.ReadParcelable<long>());\n",
+        "    if (value0Info != nullptr) {\n"
+        "    value0 = *value0Info;\n"
+        "    }\n\n"
+        "    fd.txt[*key0] = *value0;\n"
+        "}\n";
+    StringBuilder sb2;
+    emitter.EmitCppReadVar("parcel.", "fd.txt", sb2, "", false);
+    EXPECT_EQ(sb2.ToString(), expectedCode2);
+}
+
+/*
+ * @tc.name: SaArrayTypeEmitter_001
+ * @tc.desc: test SaArrayTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaArrayTypeEmitter, SaArrayTypeEmitter_001, Level1)
+{
+    GTEST_LOG_(INFO) << "SaArrayTypeEmitter, SaArrayTypeEmitter_001, TestSize.Level1";
+    SaArrayTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCount_ = 0;
+    AutoPtr<SaLongTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    std::string expectedCode =
+        "if (fd.size() > static_cast<size_t>(VECTOR_MAX_SIZE)) {\n"
+        "    HiLog::Error(LABEL, \"The vector/array size exceeds the security limit!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "parcel.WriteInt32(fd.size());\n"
+        "for (auto it0 = fd.begin(); it0 != fd.end(); ++it0) {\n"
+        "    if (!parcel.WriteInt64(fd)) {\n"
+        "        HiLog::Error(LABEL, \"Write [%s] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaArrayTypeEmitter_002
+ * @tc.desc: test SaArrayTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaArrayTypeEmitter, SaArrayTypeEmitter_002, Level1)
+{
+    GTEST_LOG_(INFO) << "SaArrayTypeEmitter, SaArrayTypeEmitter_002, TestSize.Level1";
+    SaArrayTypeEmitter emitter;
+    AutoPtr<SaLongTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    std::string type = emitter.EmitCppType(TypeMode::NO_MODE);
+    EXPECT_EQ(type, "std::vector<int64_t>");
+    type = emitter.EmitCppType(TypeMode::LOCAL_VAR);
+    EXPECT_EQ(type, "std::vector<int64_t>");
+    type = emitter.EmitCppType(TypeMode::PARAM_IN);
+    EXPECT_EQ(type, "const std::vector<int64_t>&");
+    type = emitter.EmitCppType(TypeMode::PARAM_OUT);
+    EXPECT_EQ(type, "std::vector<int64_t>&");
+    type = emitter.EmitCppType(TypeMode::PARAM_INOUT);
+    EXPECT_EQ(type, "std::vector<int64_t>&");
+    type = emitter.EmitCppType(static_cast<TypeMode>(9));
+    EXPECT_EQ(type, "unknown type");
+}
+
+/*
+ * @tc.name: SaArrayTypeEmitter_003
+ * @tc.desc: test SaArrayTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaArrayTypeEmitter, SaArrayTypeEmitter_003, Level1)
+{
+    GTEST_LOG_(INFO) << "SaArrayTypeEmitter, SaArrayTypeEmitter_003, TestSize.Level1";
+    SaArrayTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCountStr = 0;
+    AutoPtr<SaLongTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    std::string expectedCode =
+        "std::vector<int64_t> fd.txt;\n"
+        "int32_t txtSize = parcel.ReadInt32();\n"
+        "if (txtSize > static_cast<int32_t>(VECTOR_MAX_SIZE)) {\n"
+        "    HiLog::Error(LABEL, \"The vector/array size exceeds the security limit!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "for (int32_t i0 = 0; i0 < txtSize; ++i0) {\n"
+        "    int64_t value0 = parcel.ReadInt64();\n"
+        "    fd.txt.push_back(value0);\n"
+        "}\n"
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd.txt", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaArrayTypeEmitter_004
+ * @tc.desc: test SaArrayTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaArrayTypeEmitter, SaArrayTypeEmitter_004, Level1)
+{
+    GTEST_LOG_(INFO) << "SaArrayTypeEmitter, SaArrayTypeEmitter_004, TestSize.Level1";
+    SaArrayTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCountStr = 0;
+    AutoPtr<SaSeqTypeEmitter> seqEmitter = new SaSeqTypeEmitter();
+    emitter.SetElementEmitter(seqEmitter);
+    emitter.elementEmitter_->SetTypeName("long");
+    std::string expectedCode =
+        "std::vector<long> fd.txt;\n"
+        "int32_t txtSize = parcel.ReadInt32();\n"
+        "if (txtSize > static_cast<int32_t>(VECTOR_MAX_SIZE)) {\n"
+        "    HiLog::Error(LABEL, \"The vector/array size exceeds the security limit!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "for (int32_t i0 = 0; i0 < txtSize; ++i0) {\n"
+        "    std::unique_ptr<long> value0(parcel.ReadParcelable<long>());\n",
+        "    if (!value0) {\n"
+        "        HiLog::Error(LABEL, \"Read [long] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n\n"
+        "    fd.txt.push_back(*value0);\n"
+        "}\n"
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd.txt", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaArrayTypeEmitter_005
+ * @tc.desc: test SaArrayTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaArrayTypeEmitter, SaArrayTypeEmitter_005, Level1)
+{
+    GTEST_LOG_(INFO) << "SaArrayTypeEmitter, SaArrayTypeEmitter_005, TestSize.Level1";
+    SaArrayTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCountStr = 0;
+
+    AutoPtr<SaLongTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    emitter.elementEmitter_->SetTypeName("long");
+    std::string expectedCode = "let fd.txt = parcel.readLongArray();\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    AutoPtr<SaBooleanTypeEmitter> boolEmitter = new SaBooleanTypeEmitter();
+    emitter.SetElementEmitter(boolEmitter);
+    emitter.elementEmitter_->SetTypeName("bool");
+    expectedCode = "let fd.txt = parcel.readBoolArray();\n";
+    StringBuilder sb1;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb1, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb1.ToString(), expectedCode);
+    
+    AutoPtr<SaCharTypeEmitter> charEmitter = new SaCharTypeEmitter();
+    emitter.SetElementEmitter(charEmitter);
+    emitter.elementEmitter_->SetTypeName("char");
+    expectedCode = "let fd.txt = parcel.readCharArray();\n";
+    StringBuilder sb2;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb2, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb2.ToString(), expectedCode);
+
+    AutoPtr<SaByteTypeEmitter> byteEmitter = new SaByteTypeEmitter();
+    emitter.SetElementEmitter(byteEmitter);
+    emitter.elementEmitter_->SetTypeName("byte");
+    expectedCode = "let fd.txt = parcel.readByteArray();\n";
+    StringBuilder sb3;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb3, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb3.ToString(), expectedCode);
+
+    AutoPtr<SaShortTypeEmitter> shortEmitter = new SaShortTypeEmitter();
+    emitter.SetElementEmitter(shortEmitter);
+    emitter.elementEmitter_->SetTypeName("short");
+    expectedCode = "let fd.txt = parcel.readShortArray();\n";
+    StringBuilder sb4;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb4, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb4.ToString(), expectedCode);
+    
+    AutoPtr<SaIntTypeEmitter> intEmitter = new SaIntTypeEmitter();
+    emitter.SetElementEmitter(intEmitter);
+    emitter.elementEmitter_->SetTypeName("int");
+    expectedCode = "let fd.txt = parcel.readIntArray();\n";
+    StringBuilder sb5;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb5, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb5.ToString(), expectedCode);
+    
+    AutoPtr<SaLongTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    emitter.elementEmitter_->SetTypeName("long");
+    expectedCode = "let fd.txt = parcel.readLongArray();\n";
+    StringBuilder sb6;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb6, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb6.ToString(), expectedCode);
+    
+    AutoPtr<SaLongTypeEmitter> floatEmitter = new SaFloatTypeEmitter();
+    emitter.SetElementEmitter(floatEmitter);
+    emitter.elementEmitter_->SetTypeName("float");
+    expectedCode = "let fd.txt = parcel.readFloatArray();\n";
+    StringBuilder sb7;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb7, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb7.ToString(), expectedCode);
+    
+    AutoPtr<SaDoubleTypeEmitter> doubleEmitter = new SaDoubleTypeEmitter();
+    emitter.SetElementEmitter(doubleEmitter);
+    emitter.elementEmitter_->SetTypeName("double");
+    expectedCode = "let fd.txt = parcel.readDoubleArray();\n";
+    StringBuilder sb8;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb8, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb8.ToString(), expectedCode);
+    
+    AutoPtr<SaStringTypeEmitter> stringEmitter = new SaStringTypeEmitter();
+    emitter.SetElementEmitter(stringEmitter);
+    expectedCode = "let fd.txt = parcel.readStringArray();\n";
+    StringBuilder sb9;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb9, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb9.ToString(), expectedCode);
+
+    AutoPtr<SaSeqTypeEmitter> seqEmitter = new SaSeqTypeEmitter();
+    emitter.SetElementEmitter(seqEmitter);
+    emitter.elementEmitter_->SetTypeName("long");
+    expectedCode =
+        "let txtSize = parcel.readInt();\n"
+        "let fd.txt:Array<long> = [];\n"
+        "for (let index = 0; index < txtSize; index++) {\n"
+        "    let fd.txtValue = new long();\n"
+        "    parcel.readSequenceable(fd.txtValue);\n"
+        "}\n"
+    StringBuilder sb10;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb10, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb10.ToString(), expectedCode);
+
+    AutoPtr<SaCStringTypeEmitter> cstringEmitter = new SaCStringTypeEmitter();
+    emitter.SetElementEmitter(cstringEmitter);
+    expectedCode = "";
+    StringBuilder sb11;
+    emitter.EmitCppReadVar("parcel", "fd.txt", sb11, "", true);
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", true, TypeMode::NO_MODE);
+    EXPECT_EQ(sb11.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaArrayTypeEmitter_006
+ * @tc.desc: test SaArrayTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaArrayTypeEmitter, SaArrayTypeEmitter_006, Level1)
+{
+    GTEST_LOG_(INFO) << "SaArrayTypeEmitter, SaArrayTypeEmitter_006, TestSize.Level1";
+    SaArrayTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCountStr = 0;
+    AutoPtr<SaSeqTypeEmitter> seqEmitter = new SaSeqTypeEmitter();
+    emitter.SetElementEmitter(seqEmitter);
+    emitter.elementEmitter_->SetTypeName("long");
+    std::string expectedCode =
+        "std::vector<long> fd.txt;\n"
+        "int32_t txtSize = parcel.ReadInt32();\n"
+        "if (txtSize > static_cast<int32_t>(VECTOR_MAX_SIZE)) {\n"
+        "    HiLog::Error(LABEL, \"The vector/array size exceeds the security limit!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "for (int32_t i0 = 0; i0 < txtSize; ++i0) {\n"
+        "    std::unique_ptr<long> value0(parcel.ReadParcelable<long>());\n",
+        "    if (!value0) {\n"
+        "        HiLog::Error(LABEL, \"Read [long] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n\n"
+        "    fd.txt.push_back(*value0);\n"
+        "}\n"
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd.txt", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+}
+
+/*
+ * @tc.name: SaArrayTypeEmitter_007
+ * @tc.desc: test SaArrayTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaArrayTypeEmitter, SaArrayTypeEmitter_007, Level1)
+{
+    GTEST_LOG_(INFO) << "SaArrayTypeEmitter, SaArrayTypeEmitter_007, TestSize.Level1";
+    SaArrayTypeEmitter emitter;
+    SaLongTypeEmitter longEmitter;
+    emitter.SetElementEmitter(longEmitter);
+    std::string stringHelper = emitter.EmitRustType(true, TypeMode::LOCAL_VAR);
+    EXPECT_EQ(stringHelper, "[i64]");
+    stringHelper = emitter.EmitRustType(false, TypeMode::LOCAL_VAR);
+    EXPECT_EQ(stringHelper, "Vec<i64>");
+}
+
+/*
+ * @tc.name: SaArrayTypeEmitter_008
+ * @tc.desc: test SaArrayTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaArrayTypeEmitter, SaArrayTypeEmitter_008, Level1)
+{
+    GTEST_LOG_(INFO) << "SaArrayTypeEmitter, SaArrayTypeEmitter_008, TestSize.Level1";
+    SaArrayTypeEmitter emitter;
+    SaLongTypeEmitter longEmitter;
+    emitter.SetElementEmitter(longEmitter);
+    std::string stringHelper = emitter.EmitTsType(static_cast<TypeMode>(9));
+    EXPECT_EQ(stringHelper, "unknown type");
+    stringHelper = emitter.EmitTsType(TypeMode::LOCAL_VAR);
+    EXPECT_EQ(stringHelper, "i64[]");
+}
+
+/*
+ * @tc.name: SaArrayTypeEmitter_009
+ * @tc.desc: test SaArrayTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SaArrayTypeEmitter, SaArrayTypeEmitter_009, Level1)
+{
+    GTEST_LOG_(INFO) << "SaArrayTypeEmitter, SaArrayTypeEmitter_009, TestSize.Level1";
+    SaListTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCount_ = 0;
+    AutoPtr<SaLongTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    std::string expectedCode =
+        "if (fd.size() > static_cast<size_t>(VECTOR_MAX_SIZE)) {\n"
+        "    HiLog::Error(LABEL, \"The list size exceeds the security limit!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "parcel.WriteInt32(fd.size());\n"
+        "for (auto it0 = fd.begin(); it0 != fd.end(); ++it0) {\n"
+        "    if (!parcel.WriteInt64(fd)) {\n"
+        "        HiLog::Error(LABEL, \"Write [fd] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    std::string ret = emitter.EmitRustType(true, TypeMode::NO_MODE);
+    EXPECT_EQ(ret, "i64");
+
+    ret = emitter.EmitTsType(TypeMode::NO_MODE);
+    EXPECT_EQ(ret, "number");;
+}
 } // namespace OHOS
\ No newline at end of file