diff --git a/idl_tool_2/test/unittest/sa_type_emitter_test/BUILD.gn b/idl_tool_2/test/unittest/sa_type_emitter_test/BUILD.gn
index 902968b1f390463c428dd9b035a9d60a3318b9ac..fbcb597f92a0867631cbb1526245c186036f451e 100644
--- a/idl_tool_2/test/unittest/sa_type_emitter_test/BUILD.gn
+++ b/idl_tool_2/test/unittest/sa_type_emitter_test/BUILD.gn
@@ -26,10 +26,13 @@ config("idl_tool_2_test_config") {
 
 common_sources = [
   "${IDL_DIR}/codegen/SA/sa_type_emitter.cpp",
+  "${IDL_DIR}/codegen/SA/type/sa_array_type_emitter.cpp",
   "${IDL_DIR}/codegen/SA/type/sa_cstring_type_emitter.cpp",
   "${IDL_DIR}/codegen/SA/type/sa_fd_type_emitter.cpp",
   "${IDL_DIR}/codegen/SA/type/sa_fdsan_type_emitter.cpp",
   "${IDL_DIR}/codegen/SA/type/sa_int_type_emitter.cpp",
+  "${IDL_DIR}/codegen/SA/type/sa_long_type_emitter.cpp",
+  "${IDL_DIR}/codegen/SA/type/sa_seq_type_emitter.cpp",
   "${IDL_DIR}/codegen/SA/type/sa_set_type_emitter.cpp",
   "${IDL_DIR}/codegen/SA/type/sa_short_type_emitter.cpp",
   "${IDL_DIR}/codegen/SA/type/sa_string_type_emitter.cpp",
@@ -48,6 +51,24 @@ common_sources = [
   "${IDL_DIR}/util/string_helper.cpp",
 ]
 
+ohos_unittest("SaArrayTypeEmitterTest") {
+  module_out_path = module_output_path
+  include_dirs = [ "${IDL_DIR}" ]
+
+  configs = [ ":idl_tool_2_test_config" ]
+  sources = [ "./sa_array_type_emitter_test.cpp" ]
+  sources += common_sources
+
+  defines = [ "IDLTOOL_GTEST" ]
+
+  deps = []
+
+  external_deps = [ "c_utils:utils" ]
+
+  part_name = "idl_tool"
+  subsystem_name = "ability"
+}
+
 ohos_unittest("SaCStringTypeEmitterTest") {
   module_out_path = module_output_path
   include_dirs = [ "${IDL_DIR}" ]
@@ -96,6 +117,24 @@ ohos_unittest("SaFdSanTypeEmitterTest") {
   subsystem_name = "ability"
 }
 
+ohos_unittest("SaLongTypeEmitterTest") {
+  module_out_path = module_output_path
+  include_dirs = [ "${IDL_DIR}" ]
+
+  configs = [ ":idl_tool_2_test_config" ]
+  sources = [ "./sa_long_type_emitter_test.cpp" ]
+  sources += common_sources
+
+  defines = [ "IDLTOOL_GTEST" ]
+
+  deps = []
+
+  external_deps = [ "c_utils:utils" ]
+
+  part_name = "idl_tool"
+  subsystem_name = "ability"
+}
+
 ohos_unittest("SaUshortTypeEmitterTest") {
   module_out_path = module_output_path
   include_dirs = [ "${IDL_DIR}" ]
@@ -112,6 +151,24 @@ ohos_unittest("SaUshortTypeEmitterTest") {
   subsystem_name = "ability"
 }
 
+ohos_unittest("SaSeqTypeEmitterTest") {
+  module_out_path = module_output_path
+  include_dirs = [ "${IDL_DIR}" ]
+
+  configs = [ ":idl_tool_2_test_config" ]
+  sources = [ "./sa_seq_type_emitter_test.cpp" ]
+  sources += common_sources
+
+  defines = [ "IDLTOOL_GTEST" ]
+
+  deps = []
+
+  external_deps = [ "c_utils:utils" ]
+
+  part_name = "idl_tool"
+  subsystem_name = "ability"
+}
+
 ohos_unittest("SaStructTypeEmitterTest") {
   module_out_path = module_output_path
   include_dirs = [ "${IDL_DIR}" ]
@@ -291,10 +348,13 @@ ohos_unittest("SaOrderedMapTypeEmitterTest") {
 group("unittest") {
   testonly = true
   deps = [
+    ":SaArrayTypeEmitterTest",
     ":SaCStringTypeEmitterTest",
     ":SaFdTypeEmitterTest",
     ":SaFdSanTypeEmitterTest",
+    ":SaLongTypeEmitterTest",
     ":SaUshortTypeEmitterTest",
+    ":SaSeqTypeEmitterTest",
     ":SaSetTypeEmitterTest",
     ":SaStructTypeEmitterTest",
     ":SaUnionTypeEmitterTest",
diff --git a/idl_tool_2/test/unittest/sa_type_emitter_test/sa_array_type_emitter_test.cpp b/idl_tool_2/test/unittest/sa_type_emitter_test/sa_array_type_emitter_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..11244ba359e19bbc4d630c71feb34c2d7f358df5
--- /dev/null
+++ b/idl_tool_2/test/unittest/sa_type_emitter_test/sa_array_type_emitter_test.cpp
@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "gtest/gtest.h"
+#include "test_log.h"
+
+#ifdef IDLTOOL_GTEST
+#define private   public
+#define protected public
+#endif
+#include "codegen/SA/type/sa_array_type_emitter.h"
+#include "codegen/SA/type/sa_long_type_emitter.h"
+#include "codegen/SA/type/sa_uchar_type_emitter.h"
+#include "codegen/SA/type/sa_seq_type_emitter.h"
+#include "codegen/SA/type/sa_string_type_emitter.h"
+#include "codegen/SA/type/sa_cstring_type_emitter.h"
+
+using namespace testing;
+using namespace testing::ext;
+using namespace OHOS::Idl;
+
+namespace OHOS::Idl {
+class SaArrayTypeEmitterTest : public testing::Test {
+public:
+    SaArrayTypeEmitterTest() {}
+    virtual ~SaArrayTypeEmitterTest() {}
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+};
+
+void SaArrayTypeEmitterTest::SetUpTestCase()
+{
+    DTEST_LOG << "SetUpTestCase" << std::endl;
+}
+
+void SaArrayTypeEmitterTest::TearDownTestCase()
+{
+    DTEST_LOG << "TearDownTestCase" << std::endl;
+}
+
+void SaArrayTypeEmitterTest::SetUp()
+{
+    DTEST_LOG << "SetUp" << std::endl;
+}
+
+void SaArrayTypeEmitterTest::TearDown()
+{
+    DTEST_LOG << "TearDown" << std::endl;
+}
+
+/*
+ * @tc.name: GetTypeKind_001
+ * @tc.desc: test SaArrayTypeEmitter GetTypeKind
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, GetTypeKind_001, Level1)
+{
+    DTEST_LOG << "GetTypeKind_001 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    auto ret = emitter.GetTypeKind();
+    EXPECT_EQ(ret, TypeKind::TYPE_ARRAY);
+    DTEST_LOG << "GetTypeKind_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppType_001
+ * @tc.desc: test SaArrayTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, EmitCppType_001, Level1)
+{
+    DTEST_LOG << "EmitCppType_001 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    AutoPtr<SaTypeEmitter> 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");
+    DTEST_LOG << "EmitCppType_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitRustType_001
+ * @tc.desc: test SaArrayTypeEmitter EmitRustType
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, EmitRustType_001, Level1)
+{
+    DTEST_LOG << "EmitRustType_001 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    AutoPtr<SaTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    std::string stringHelper = emitter.EmitRustType(true, TypeMode::NO_MODE);
+    EXPECT_EQ(stringHelper, "[i64]");
+    stringHelper = emitter.EmitRustType(false, TypeMode::NO_MODE);
+    EXPECT_EQ(stringHelper, "Vec<i64>");
+    DTEST_LOG << "EmitRustType_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsType_001
+ * @tc.desc: test SaArrayTypeEmitter EmitTsType
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, EmitTsType_001, Level1)
+{
+    DTEST_LOG << "EmitTsType_001 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    AutoPtr<SaTypeEmitter> ucharEmitter = new SaUcharTypeEmitter();
+    emitter.SetElementEmitter(ucharEmitter);
+    std::string stringHelper = emitter.EmitTsType(TypeMode::NO_MODE);
+    EXPECT_EQ(stringHelper, "unknown type");
+
+    AutoPtr<SaTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    stringHelper = emitter.EmitTsType(TypeMode::NO_MODE);
+    EXPECT_EQ(stringHelper, "number[]");
+    DTEST_LOG << "EmitTsType_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppWriteVar_001
+ * @tc.desc: test SaArrayTypeEmitter EmitCppWriteVar with log
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, EmitCppWriteVar_001, Level1)
+{
+    DTEST_LOG << "EmitCppWriteVar_001 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    AutoPtr<SaTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    emitter.logOn_ = true;
+    emitter.circleCount_ = 0;
+    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 it1 = fd.begin(); it1 != fd.end(); ++it1) {\n"
+        "    if (!parcel.WriteInt64((*it1))) {\n"
+        "        HiLog::Error(LABEL, \"Write [(*it1)] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppWriteVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppWriteVar_002
+ * @tc.desc: test SaArrayTypeEmitter EmitCppWriteVar without log
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, EmitCppWriteVar_002, Level1)
+{
+    DTEST_LOG << "EmitCppWriteVar_002 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    AutoPtr<SaTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    emitter.logOn_ = false;
+    emitter.circleCount_ = 0;
+    std::string expectedCode =
+        "if (fd.size() > static_cast<size_t>(VECTOR_MAX_SIZE)) {\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "parcel.WriteInt32(fd.size());\n"
+        "for (auto it1 = fd.begin(); it1 != fd.end(); ++it1) {\n"
+        "    if (!parcel.WriteInt64((*it1))) {\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppWriteVar_002 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppReadVar_001
+ * @tc.desc: test SaArrayTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, EmitCppReadVar_001, Level1)
+{
+    DTEST_LOG << "EmitCppReadVar_001 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCount_ = 0;
+    AutoPtr<SaTypeEmitter> 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 i1 = 0; i1 < txtSize; ++i1) {\n"
+        "    int64_t value1 = parcel.ReadInt64();\n"
+        "    fd.txt.push_back(value1);\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd.txt", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppReadVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppReadVar_002
+ * @tc.desc: test SaArrayTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, EmitCppReadVar_002, Level1)
+{
+    DTEST_LOG << "EmitCppReadVar_002 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCount_ = 0;
+    AutoPtr<SaTypeEmitter> 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 i1 = 0; i1 < txtSize; ++i1) {\n"
+        "    std::unique_ptr<long> value1(parcel.ReadParcelable<long>());\n"
+        "    if (!value1) {\n"
+        "        HiLog::Error(LABEL, \"Read [long] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n\n"
+        "    fd.txt.push_back(*value1);\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd.txt", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppReadVar_002 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsWriteVar_001
+ * @tc.desc: test SaArrayTypeEmitter EmitTsWriteVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, EmitTsWriteVar_001, Level1)
+{
+    DTEST_LOG << "EmitTsWriteVar_001 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCount_ = 0;
+
+    AutoPtr<SaTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    emitter.elementEmitter_->SetTypeName("long");
+    std::string expectedCode = "parcel.writeLongArray(fd.txt);\n";
+    StringBuilder sb;
+    emitter.EmitTsWriteVar("parcel", "fd.txt", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    AutoPtr<SaTypeEmitter> stringEmitter = new SaStringTypeEmitter();
+    emitter.SetElementEmitter(stringEmitter);
+    expectedCode = "parcel.writeStringArray(fd.txt);\n";
+    StringBuilder sb1;
+    emitter.EmitTsWriteVar("parcel", "fd.txt", sb1, "");
+    EXPECT_EQ(sb1.ToString(), expectedCode);
+
+    AutoPtr<SaTypeEmitter> seqEmitter = new SaSeqTypeEmitter();
+    emitter.SetElementEmitter(seqEmitter);
+    emitter.elementEmitter_->SetTypeName("long");
+    expectedCode =
+        "let fd.txtArray:Array<long> = fd.txt;\n"
+        "parcel.writeInt(fd.txtArray.length);\n"
+        "for (let index = 0; index < fd.txtArray.length; index++) {\n"
+        "    parcel.writeSequenceable(fd.txt[index]);\n"
+        "}\n";
+    StringBuilder sb2;
+    emitter.EmitTsWriteVar("parcel", "fd.txt", sb2, "");
+    EXPECT_EQ(sb2.ToString(), expectedCode);
+
+    AutoPtr<SaTypeEmitter> cstringEmitter = new SaCStringTypeEmitter();
+    emitter.SetElementEmitter(cstringEmitter);
+    expectedCode = "";
+    StringBuilder sb3;
+    emitter.EmitTsWriteVar("parcel", "fd.txt", sb3, "");
+    EXPECT_EQ(sb3.ToString(), expectedCode);
+    DTEST_LOG << "EmitTsWriteVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsReadVar_001
+ * @tc.desc: test SaArrayTypeEmitter EmitTsReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, EmitTsReadVar_001, Level1)
+{
+    DTEST_LOG << "EmitTsReadVar_001 begin" << std::endl;
+    SaArrayTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCount_ = 0;
+
+    AutoPtr<SaTypeEmitter> longEmitter = new SaLongTypeEmitter();
+    emitter.SetElementEmitter(longEmitter);
+    emitter.elementEmitter_->SetTypeName("long");
+    std::string expectedCode = "let fd.txt = parcel.readLongArray();\n";
+    StringBuilder sb;
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb, "", TypeMode::NO_MODE);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    AutoPtr<SaTypeEmitter> stringEmitter = new SaStringTypeEmitter();
+    emitter.SetElementEmitter(stringEmitter);
+    expectedCode = "let fd.txt = parcel.readStringArray();\n";
+    StringBuilder sb1;
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb1, "", TypeMode::NO_MODE);
+    EXPECT_EQ(sb1.ToString(), expectedCode);
+
+    AutoPtr<SaTypeEmitter> 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"
+        "    fd.txt.push(fd.txtValue);\n"
+        "}\n";
+    StringBuilder sb2;
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb2, "", TypeMode::NO_MODE);
+    EXPECT_EQ(sb2.ToString(), expectedCode);
+
+    AutoPtr<SaTypeEmitter> cstringEmitter = new SaCStringTypeEmitter();
+    emitter.SetElementEmitter(cstringEmitter);
+    expectedCode = "";
+    StringBuilder sb3;
+    emitter.EmitTsReadVar("parcel", "fd.txt", sb3, "", TypeMode::NO_MODE);
+    EXPECT_EQ(sb3.ToString(), expectedCode);
+    DTEST_LOG << "EmitTsReadVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: SaListTypeEmitter_001
+ * @tc.desc: test SaArrayTypeEmitter SaListTypeEmitter
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaArrayTypeEmitterTest, SaListTypeEmitter_001, Level1)
+{
+    DTEST_LOG << "SaListTypeEmitter_001 start" << std::endl;
+    SaListTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.circleCount_ = 0;
+    AutoPtr<SaTypeEmitter> 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 it1 = fd.begin(); it1 != fd.end(); ++it1) {\n"
+        "    if (!parcel.WriteInt64((*it1))) {\n"
+        "        HiLog::Error(LABEL, \"Write [(*it1)] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    TypeKind type = emitter.GetTypeKind();
+    EXPECT_EQ(type, TypeKind::TYPE_LIST);
+
+    std::string ret = emitter.EmitTsType(TypeMode::NO_MODE);
+    EXPECT_EQ(ret, "unknown type");
+    DTEST_LOG << "SaListTypeEmitter_001 end" << std::endl;
+}
+} // namespace OHOS::idl
\ No newline at end of file
diff --git a/idl_tool_2/test/unittest/sa_type_emitter_test/sa_long_type_emitter_test.cpp b/idl_tool_2/test/unittest/sa_type_emitter_test/sa_long_type_emitter_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e74f033d9e9729a9b6b9b54f72b86bc76dc58664
--- /dev/null
+++ b/idl_tool_2/test/unittest/sa_type_emitter_test/sa_long_type_emitter_test.cpp
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "gtest/gtest.h"
+#include "test_log.h"
+
+#ifdef IDLTOOL_GTEST
+#define private   public
+#define protected public
+#endif
+#include "codegen/SA/type/sa_long_type_emitter.h"
+
+using namespace testing;
+using namespace testing::ext;
+using namespace OHOS::Idl;
+
+namespace OHOS::Idl {
+class SaLongTypeEmitterTest : public testing::Test {
+public:
+    SaLongTypeEmitterTest() {}
+    virtual ~SaLongTypeEmitterTest() {}
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+};
+
+void SaLongTypeEmitterTest::SetUpTestCase()
+{
+    DTEST_LOG << "SetUpTestCase" << std::endl;
+}
+
+void SaLongTypeEmitterTest::TearDownTestCase()
+{
+    DTEST_LOG << "TearDownTestCase" << std::endl;
+}
+
+void SaLongTypeEmitterTest::SetUp()
+{
+    DTEST_LOG << "SetUp" << std::endl;
+}
+
+void SaLongTypeEmitterTest::TearDown()
+{
+    DTEST_LOG << "TearDown" << std::endl;
+}
+
+/*
+ * @tc.name: GetTypeKind_001
+ * @tc.desc: test SaLongTypeEmitter GetTypeKind
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, GetTypeKind_001, Level1)
+{
+    DTEST_LOG << "GetTypeKind_001 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    auto ret = emitter.GetTypeKind();
+    EXPECT_EQ(ret, TypeKind::TYPE_LONG);
+    DTEST_LOG << "GetTypeKind_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppType_001
+ * @tc.desc: test SaLongTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, EmitCppType_001, Level1)
+{
+    DTEST_LOG << "EmitCppType_001 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    std::string type = emitter.EmitCppType(TypeMode::NO_MODE);
+    EXPECT_EQ(type, "int64_t");
+    type = emitter.EmitCppType(TypeMode::PARAM_IN);
+    EXPECT_EQ(type, "int64_t");
+    type = emitter.EmitCppType(TypeMode::LOCAL_VAR);
+    EXPECT_EQ(type, "int64_t");
+    type = emitter.EmitCppType(TypeMode::PARAM_INOUT);
+    EXPECT_EQ(type, "int64_t&");
+    type = emitter.EmitCppType(TypeMode::PARAM_OUT);
+    EXPECT_EQ(type, "int64_t&");
+    type = emitter.EmitCppType(static_cast<TypeMode>(9));
+    EXPECT_EQ(type, "unknown type");
+    DTEST_LOG << "EmitCppType_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitRustType_001
+ * @tc.desc: test SaLongTypeEmitter EmitRustType
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, EmitRustType_001, Level1)
+{
+    DTEST_LOG << "EmitRustType_001 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    std::string stringHelper = emitter.EmitRustType(true, TypeMode::NO_MODE);
+    EXPECT_EQ(stringHelper, "i64");
+    DTEST_LOG << "EmitRustType_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsType_001
+ * @tc.desc: test SaLongTypeEmitter EmitTsType
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, EmitTsType_001, Level1)
+{
+    DTEST_LOG << "EmitTsType_001 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    std::string stringHelper = emitter.EmitTsType(TypeMode::NO_MODE);
+    EXPECT_EQ(stringHelper, "number");
+    DTEST_LOG << "EmitTsType_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppWriteVar_001
+ * @tc.desc: test SaLongTypeEmitter EmitCppWriteVar with log
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, EmitCppWriteVar_001, Level1)
+{
+    DTEST_LOG << "EmitCppWriteVar_001 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    emitter.logOn_ = true;
+    std::string expectedCode =
+        "if (!parcel.WriteInt64(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);
+    DTEST_LOG << "EmitCppWriteVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppWriteVar_002
+ * @tc.desc: test SaLongTypeEmitter EmitCppWriteVar with log
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, EmitCppWriteVar_002, Level1)
+{
+    DTEST_LOG << "EmitCppWriteVar_002 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    emitter.logOn_ = false;
+    std::string expectedCode =
+        "if (!parcel.WriteInt64(fd)) {\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppWriteVar("parcel.", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppWriteVar_002 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppReadVar_001
+ * @tc.desc: test SaLongTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, EmitCppReadVar_001, Level1)
+{
+    DTEST_LOG << "EmitCppReadVar_001 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    std::string expectedCode = "int64_t fd = parcel.ReadInt64();\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppReadVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppReadVar_002
+ * @tc.desc: test SaLongTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, EmitCppReadVar_002, Level1)
+{
+    DTEST_LOG << "EmitCppReadVar_002 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    std::string expectedCode = "fd = parcel.ReadInt64();\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd", sb, "", false);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppReadVar_002 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsWriteVar_001
+ * @tc.desc: test SaLongTypeEmitter EmitTsWriteVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, EmitTsWriteVar_001, Level1)
+{
+    DTEST_LOG << "EmitTsWriteVar_001 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    std::string expectedCode = "parcel.writeLong(fd);\n";
+    StringBuilder sb;
+    emitter.EmitTsWriteVar("parcel", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitTsWriteVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsReadVar_001
+ * @tc.desc: test SaLongTypeEmitter EmitTsReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaLongTypeEmitterTest, EmitTsReadVar_001, Level1)
+{
+    DTEST_LOG << "EmitTsReadVar_001 begin" << std::endl;
+    SaLongTypeEmitter emitter;
+    std::string expectedCode = "let fd = parcel.readLong();\n";
+    StringBuilder sb;
+    emitter.EmitTsReadVar("parcel", "fd", sb, "", TypeMode::NO_MODE);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitTsReadVar_001 end" << std::endl;
+}
+} // namespace OHOS::idl
\ No newline at end of file
diff --git a/idl_tool_2/test/unittest/sa_type_emitter_test/sa_seq_type_emitter_test.cpp b/idl_tool_2/test/unittest/sa_type_emitter_test/sa_seq_type_emitter_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4a7a9a5ebb4899fa558503999d0c1592478d7a21
--- /dev/null
+++ b/idl_tool_2/test/unittest/sa_type_emitter_test/sa_seq_type_emitter_test.cpp
@@ -0,0 +1,491 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "gtest/gtest.h"
+#include "test_log.h"
+
+#ifdef IDLTOOL_GTEST
+#define private   public
+#define protected public
+#endif
+#include "codegen/SA/sa_type_emitter.h"
+#include "codegen/SA/type/sa_long_type_emitter.h"
+#include "codegen/SA/type/sa_seq_type_emitter.h"
+
+using namespace testing;
+using namespace testing::ext;
+using namespace OHOS::Idl;
+
+namespace OHOS::Idl {
+class SaSeqTypeEmitterTest : public testing::Test {
+public:
+    SaSeqTypeEmitterTest() {}
+    virtual ~SaSeqTypeEmitterTest() {}
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+};
+
+void SaSeqTypeEmitterTest::SetUpTestCase()
+{
+    DTEST_LOG << "SetUpTestCase" << std::endl;
+}
+
+void SaSeqTypeEmitterTest::TearDownTestCase()
+{
+    DTEST_LOG << "TearDownTestCase" << std::endl;
+}
+
+void SaSeqTypeEmitterTest::SetUp()
+{
+    DTEST_LOG << "SetUp" << std::endl;
+}
+
+void SaSeqTypeEmitterTest::TearDown()
+{
+    DTEST_LOG << "TearDown" << std::endl;
+}
+
+/*
+ * @tc.name: GetTypeKind_001
+ * @tc.desc: test SaSeqTypeEmitter GetTypeKind
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, GetTypeKind_001, Level1)
+{
+    DTEST_LOG << "GetTypeKind_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    auto ret = emitter.GetTypeKind();
+    EXPECT_EQ(ret, TypeKind::TYPE_SEQUENCEABLE);
+    DTEST_LOG << "GetTypeKind_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppType_001
+ * @tc.desc: test SaSeqTypeEmitter EmitCppType
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppType_001, Level1)
+{
+    DTEST_LOG << "EmitCppType_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.SetTypeName("long");
+    std::string type = emitter.EmitCppType(TypeMode::PARAM_IN);
+    EXPECT_EQ(type, "const long&");
+    type = emitter.EmitCppType(TypeMode::PARAM_INOUT);
+    EXPECT_EQ(type, "long&");
+    type = emitter.EmitCppType(TypeMode::PARAM_OUT);
+    EXPECT_EQ(type, "long&");
+    type = emitter.EmitCppType(TypeMode::NO_MODE);
+    EXPECT_EQ(type, "long");
+    type = emitter.EmitCppType(TypeMode::LOCAL_VAR);
+    EXPECT_EQ(type, "long");
+    type = emitter.EmitCppType(static_cast<TypeMode>(9));
+    EXPECT_EQ(type, "unknown type");
+
+    emitter.SetTypeName("IRemoteObject");
+    type = emitter.EmitCppType(TypeMode::PARAM_IN);
+    EXPECT_EQ(type, "const sptr<IRemoteObject>&");
+    type = emitter.EmitCppType(TypeMode::PARAM_INOUT);
+    EXPECT_EQ(type, "sptr<IRemoteObject>&");
+    type = emitter.EmitCppType(TypeMode::PARAM_OUT);
+    EXPECT_EQ(type, "sptr<IRemoteObject>&");
+    type = emitter.EmitCppType(TypeMode::NO_MODE);
+    EXPECT_EQ(type, "sptr<IRemoteObject>");
+    type = emitter.EmitCppType(TypeMode::LOCAL_VAR);
+    EXPECT_EQ(type, "sptr<IRemoteObject>");
+    type = emitter.EmitCppType(static_cast<TypeMode>(9));
+    EXPECT_EQ(type, "unknown type");
+    DTEST_LOG << "EmitCppType_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitRustType_001
+ * @tc.desc: test SaSeqTypeEmitter EmitRustType
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitRustType_001, Level1)
+{
+    DTEST_LOG << "EmitRustType_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.SetTypeName("long");
+    std::string stringHelper = emitter.EmitRustType(true, TypeMode::NO_MODE);
+    EXPECT_EQ(stringHelper, "long");
+    DTEST_LOG << "EmitRustType_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsType_001
+ * @tc.desc: test SaSeqTypeEmitter EmitTsType
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitTsType_001, Level1)
+{
+    DTEST_LOG << "EmitTsType_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.SetTypeName("long");
+    std::string stringHelper = emitter.EmitTsType(TypeMode::NO_MODE);
+    EXPECT_EQ(stringHelper, "long");
+    DTEST_LOG << "EmitTsType_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppWriteVar_001
+ * @tc.desc: test SaSeqTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppWriteVar_001, Level1)
+{
+    DTEST_LOG << "EmitCppWriteVar_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.SetTypeName("IRemoteObject");
+    std::string expectedCode =
+        "if (!parcel.WriteRemoteObject(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);
+    DTEST_LOG << "EmitCppWriteVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppWriteVar_002
+ * @tc.desc: test SaSeqTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppWriteVar_002, Level1)
+{
+    DTEST_LOG << "EmitCppWriteVar_002 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.isParamInout = true;
+    emitter.isProxy = false;
+    emitter.SetTypeName("long");
+    std::string expectedCode =
+        "if (!parcel.WriteParcelable(fd.get())) {\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);
+    DTEST_LOG << "EmitCppWriteVar_002 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppWriteVar_003
+ * @tc.desc: test SaSeqTypeEmitter EmitCppWriteVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppWriteVar_003, Level1)
+{
+    DTEST_LOG << "EmitCppWriteVar_003 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.isParamInout = false;
+    emitter.isProxy = false;
+    emitter.SetTypeName("long");
+    std::string expectedCode =
+        "if (!parcel.WriteParcelable(&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);
+    DTEST_LOG << "EmitCppWriteVar_003 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppReadVar_001
+ * @tc.desc: test SaSeqTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppReadVar_001, Level1)
+{
+    DTEST_LOG << "EmitCppReadVar_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.SetTypeName("IRemoteObject");
+    std::string expectedCode =
+        "sptr<IRemoteObject> fd = parcel.ReadRemoteObject();\n"
+        "if (!fd) {\n"
+        "    HiLog::Error(LABEL, \"Read [IRemoteObject] failed!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppReadVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppReadVar_002
+ * @tc.desc: test SaSeqTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppReadVar_002, Level1)
+{
+    DTEST_LOG << "EmitCppReadVar_002 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.SetTypeName("IRemoteObject");
+    std::string expectedCode = "fd = parcel.ReadRemoteObject();\n\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd", sb, "", false);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppReadVar_002 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppReadVar_003
+ * @tc.desc: test SaSeqTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppReadVar_003, Level1)
+{
+    DTEST_LOG << "EmitCppReadVar_003 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.SetTypeName("long");
+    std::string expectedCode =
+        "std::unique_ptr<long> fd(parcel.ReadParcelable<long>());\n"
+        "if (!fd) {\n"
+        "    HiLog::Error(LABEL, \"Read [long] failed!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd", sb, "", true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppReadVar_003 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppReadVar_004
+ * @tc.desc: test SaSeqTypeEmitter EmitCppReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppReadVar_004, Level1)
+{
+    DTEST_LOG << "EmitCppReadVar_004 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.logOn_ = true;
+    emitter.SetTypeName("long");
+    std::string expectedCode =
+        "std::unique_ptr<long> fdInfo(parcel.ReadParcelable<long>());\n"
+        "if (fdInfo != nullptr) {\n"
+        "    fd = *fdInfo;\n"
+        "}\n\n";
+    StringBuilder sb;
+    emitter.EmitCppReadVar("parcel.", "fd", sb, "", false);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppReadVar_004 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppPtrWriteVar_001
+ * @tc.desc: test SaSeqTypeEmitter EmitCppPtrWriteVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppPtrWriteVar_001, Level1)
+{
+    DTEST_LOG << "EmitCppPtrWriteVar_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    EmitCppPtrVar emitCppPtrVar = { "parcel.", "fd", "", "sptr", true };
+    std::string expectedCode =
+        "bool fdValid = fd != nullptr;\n"
+        "if (!parcel.WriteBool(fdValid)) {\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "if (fdValid) {\n"
+        "    if (!parcel.WriteParcelable(fd)) {\n"
+        "        HiLog::Error(LABEL, \"Write [fd] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppPtrWriteVar(emitCppPtrVar, sb);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppPtrWriteVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppPtrWriteVar_002
+ * @tc.desc: test SaSeqTypeEmitter EmitCppPtrWriteVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppPtrWriteVar_002, Level1)
+{
+    DTEST_LOG << "EmitCppPtrWriteVar_002 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    EmitCppPtrVar emitCppPtrVar = { "parcel.", "fd", "", "uptr", true };
+    std::string expectedCode =
+        "bool fdValid = fd != nullptr;\n"
+        "if (!parcel.WriteBool(fdValid)) {\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n"
+        "if (fdValid) {\n"
+        "    if (!parcel.WriteParcelable(fd.get())) {\n"
+        "        HiLog::Error(LABEL, \"Write [fd] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppPtrWriteVar(emitCppPtrVar, sb);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppPtrWriteVar_002 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppPtrReadVar_001
+ * @tc.desc: test SaSeqTypeEmitter EmitCppPtrReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppPtrReadVar_001, Level1)
+{
+    DTEST_LOG << "EmitCppPtrReadVar_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    EmitCppPtrVar emitCppPtrVar = { "parcel.", "ptr", "", "sptr", true };
+    emitter.SetTypeName("long");
+    std::string expectedCode =
+        "sptr<long> ptr;\n"
+        "if (parcel.ReadBool()) {\n"
+        "    ptr = sptr<long>(parcel.ReadParcelable<long>());\n"
+        "    if (!ptr) {\n"
+        "        HiLog::Error(LABEL, \"Read [long] failed!\");\n"
+        "        return ERR_INVALID_DATA;\n"
+        "    }\n"
+        "}\n\n";
+    StringBuilder sb;
+    emitter.EmitCppPtrReadVar(emitCppPtrVar, sb, true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppPtrReadVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitCppPtrReadVar_002
+ * @tc.desc: test SaSeqTypeEmitter EmitCppPtrReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitCppPtrReadVar_002, Level1)
+{
+    DTEST_LOG << "EmitCppPtrReadVar_002 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    EmitCppPtrVar emitCppPtrVar = { "parcel.", "ptr", "", "sptr", false };
+    emitter.SetTypeName("long");
+    std::string expectedCode =
+        "sptr<long> "
+        "ptr = sptr<long>(parcel.ReadParcelable<long>());\n"
+        "if (!ptr) {\n"
+        "    HiLog::Error(LABEL, \"Read [long] failed!\");\n"
+        "    return ERR_INVALID_DATA;\n"
+        "}\n";
+    StringBuilder sb;
+    emitter.EmitCppPtrReadVar(emitCppPtrVar, sb, true);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    DTEST_LOG << "EmitCppPtrReadVar_002 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsWriteVar_001
+ * @tc.desc: test SaSeqTypeEmitter EmitTsWriteVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitTsWriteVar_001, Level1)
+{
+    DTEST_LOG << "EmitTsWriteVar_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.SetTypeName("IRemoteObject");
+    std::string expectedCode = "parcel.writeRemoteObject(fd);\n";
+    StringBuilder sb;
+    emitter.EmitTsWriteVar("parcel", "fd", sb, "");
+    EXPECT_EQ(sb.ToString(), expectedCode);
+
+    emitter.SetTypeName("long");
+    expectedCode = "parcel.writeParcelable(fd);\n";
+    StringBuilder sb2;
+    emitter.EmitTsWriteVar("parcel", "fd", sb2, "");
+    EXPECT_EQ(sb2.ToString(), expectedCode);
+    DTEST_LOG << "EmitTsWriteVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsReadVar_001
+ * @tc.desc: test SaSeqTypeEmitter EmitTsReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitTsReadVar_001, Level1)
+{
+    DTEST_LOG << "EmitTsReadVar_001 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.SetTypeName("IRemoteObject");
+    std::string expectedCode = "IRemoteObject fd = parcel.readRemoteObject();\n";
+    StringBuilder sb;
+    emitter.EmitTsReadVar("parcel", "fd", sb, "", TypeMode::PARAM_IN);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    expectedCode = "fd = parcel.readRemoteObject();\n";
+    StringBuilder sb2;
+    emitter.EmitTsReadVar("parcel", "fd", sb2, "", TypeMode::NO_MODE);
+    EXPECT_EQ(sb2.ToString(), expectedCode);
+    DTEST_LOG << "EmitTsReadVar_001 end" << std::endl;
+}
+
+/*
+ * @tc.name: EmitTsReadVar_002
+ * @tc.desc: test SaSeqTypeEmitter EmitTsReadVar
+ * @tc.type: FUNC
+ * @tc.require: issueICL05Z
+ */
+HWTEST_F(SaSeqTypeEmitterTest, EmitTsReadVar_002, Level1)
+{
+    DTEST_LOG << "EmitTsReadVar_002 begin" << std::endl;
+    SaSeqTypeEmitter emitter;
+    emitter.SetTypeName("long");
+    std::string expectedCode =
+        "let fd = new long();\n"
+        "parcel.readParcelable(fd);\n";
+    StringBuilder sb;
+    emitter.EmitTsReadVar("parcel", "fd", sb, "", TypeMode::PARAM_IN);
+    EXPECT_EQ(sb.ToString(), expectedCode);
+    expectedCode =
+        "let fd = new long();\n"
+        "parcel.readSequenceable(fd);\n";
+    StringBuilder sb2;
+    emitter.EmitTsReadVar("parcel", "fd", sb2, "", TypeMode::NO_MODE);
+    EXPECT_EQ(sb2.ToString(), expectedCode);
+    DTEST_LOG << "EmitTsReadVar_002 end" << std::endl;
+}
+} // namespace OHOS::idl
\ No newline at end of file