!76 RPC支持基础数据类型序列化/反序列化 XTS test

Merge pull request !76 from 穆天亮/master

ipc/test/serializer/BUILD.gn

+# Copyright (c) 2022 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.
+
+import("//test/xts/tools/lite/build/suite_lite.gni")
+if (ohos_kernel_type == "linux") {
+  hcpptest_suite("SerializerTest") {
+    suite_name = "acts"
+    sources = [ "utils_serializer_test.cpp" ]
+    defines = [ "XTS_SUITE_TEST" ]
+    include_dirs = [
+      "//foundation/communication/ipc/interfaces/innerkits/c/ipc/include",
+      "//foundation/communication/ipc/ipc/native/c/manager/include",
+    ]
+    deps = [
+      "//foundation/communication/ipc/interfaces/innerkits/c/ipc:ipc_single",
+    ]
+  }
+}

ipc/test/serializer/Test.json

+{
+    "description": "Config for hcpptest demo test cases",
+    "environment": [
+        {
+            "type": "device",
+            "label": "serializer"
+        }
+    ],
+    "kits": [
+        {
+            "type": "MountKit",
+            "server": "NfsServer",
+            "mount": [
+                {
+                    "source": "testcases/communication",
+                    "target": "/test_root/communication"
+                }
+            ]
+        }
+    ],
+    "driver": {
+        "type": "CppTestLite",
+        "execute": "/test_root/communication/SerializerTest.bin"
+    }
+}

ipc/test/serializer/utils_serializer_test.cpp

+/*
+ * Copyright (c) 2022 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 <iostream>
+#include <unistd.h>
+#include <csignal>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "serializer.h"
+
+using namespace testing::ext;
+using namespace std;
+
+const int BUFFER_SIZE = 200;
+const int SMALL_BUFFER_SIZE = 100;
+
+class UtilsSerializerTest : public testing::Test {
+public:
+    static void SetUpTestCase() { }
+    static void TearDownTestCase() { }
+    void SetUp() { }
+    void TearDown() { }
+};
+struct TestData {
+    bool boolTest;
+    int8_t int8Test;
+    int16_t int16Test;
+    int32_t int32Test;
+    uint8_t uint8Test;
+    uint16_t uint16Test;
+    uint32_t uint32Test;
+};
+struct Padded {
+    char title;
+    int32_t handle;
+    uint64_t cookie;
+};
+struct Unpadded {
+    char tip;
+};
+
+void WriteTestData(IpcIo* io, const struct TestData &data)
+{
+    bool result = false;
+
+    result = WriteBool(io, data.boolTest);
+    EXPECT_EQ(result, true);
+
+    result = WriteInt8(io, data.int8Test);
+    EXPECT_EQ(result, true);
+
+    result = WriteInt16(io, data.int16Test);
+    EXPECT_EQ(result, true);
+
+    result = WriteInt32(io, data.int32Test);
+    EXPECT_EQ(result, true);
+
+    result = WriteUint8(io, data.uint8Test);
+    EXPECT_EQ(result, true);
+
+    result = WriteUint16(io, data.uint16Test);
+    EXPECT_EQ(result, true);
+
+    result = WriteUint32(io, data.uint32Test);
+    EXPECT_EQ(result, true);
+}
+
+void ReadTestData(IpcIo* io, const struct TestData &data)
+{
+    bool boolVal;
+    bool result = ReadBool(io, &boolVal);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(boolVal, data.boolTest);
+
+    int8_t int8Val;
+    result = ReadInt8(io, &int8Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(int8Val, data.int8Test);
+
+    int16_t int16Val;
+    result = ReadInt16(io, &int16Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(int16Val, data.int16Test);
+
+    int32_t int32Val;
+    result = ReadInt32(io, &int32Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(int32Val, data.int32Test);
+
+    uint8_t uint8Val;
+    result = ReadUint8(io, &uint8Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(uint8Val, data.uint8Test);
+
+    uint16_t uint16Val;
+    result = ReadUint16(io, &uint16Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(uint16Val, data.uint16Test);
+
+    uint32_t uint32Val;
+    result = ReadUint32(io, &uint32Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(uint32Val, data.uint32Test);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_001
+ * @tc.desc: test serializer primary type read write.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_001, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+
+    if (pipe(fd) < 0) {
+        perror("pipe error!\n");
+        return;
+    }
+
+    struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
+    pid = fork();
+    if (pid < 0) {
+        return;
+    }
+    else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+        WriteTestData(&io, data);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+
+    } else {
+        close(fd[1]);
+
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+
+        ReadTestData(&io, data);
+        close(fd[0]);
+    }
+}
+
+void WriteTestDataUnaligned(IpcIo* io, const struct TestData &data)
+{
+    bool result = false;
+
+    result = WriteBoolUnaligned(io, data.boolTest);
+    EXPECT_EQ(result, true);
+
+    result = WriteInt8Unaligned(io, data.int8Test);
+    EXPECT_EQ(result, true);
+
+    result = WriteInt16Unaligned(io, data.int16Test);
+    EXPECT_EQ(result, true);
+
+    result = WriteUint8Unaligned(io, data.uint8Test);
+    EXPECT_EQ(result, true);
+
+    result = WriteUint16Unaligned(io, data.uint16Test);
+    EXPECT_EQ(result, true);
+}
+
+void ReadTestDataUnaligned(IpcIo* io, const struct TestData &data)
+{
+    bool result = false;
+
+    bool boolVal;
+    result = ReadBoolUnaligned(io, &boolVal);
+    EXPECT_EQ(boolVal, data.boolTest);
+
+    int8_t int8Val;
+    result = ReadInt8Unaligned(io, &int8Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(int8Val, data.int8Test);
+
+    int16_t int16Val;
+    result = ReadInt16Unaligned(io, &int16Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(int16Val, data.int16Test);
+
+    uint8_t uint8Val;
+    result = ReadUInt8Unaligned(io, &uint8Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(uint8Val, data.uint8Test);
+
+    uint16_t uint16Val;
+    result = ReadUInt16Unaligned(io, &uint16Val);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(uint16Val, data.uint16Test);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_002
+ * @tc.desc: test serializer primary type read write.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_002, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+
+    if (pipe(fd) < 0) {
+        perror("pipe error!\n");
+        return;
+    }
+    struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 };
+    pid = fork();
+    if (pid < 0) {
+        return;
+    } else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+        WriteTestDataUnaligned(&io, data);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        ReadTestDataUnaligned(&io, data);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_003
+ * @tc.desc: test serializer primary type read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_003, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    int64_t int64Test = -0x1234567887654321;
+    uint64_t uint64Test = 0x1234567887654321;
+    pid = fork();
+    if (pid < 0) {
+        return;
+    }
+    else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteInt64(&io, int64Test);
+        EXPECT_EQ(result, true);
+        result = WriteUint64(&io, uint64Test);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        int64_t int64Read;
+        result = ReadInt64(&io, &int64Read);
+        EXPECT_EQ(result, true);
+        EXPECT_EQ(int64Read, int64Test);
+        uint64_t uint64Read;
+        result = ReadUint64(&io, &uint64Read);
+        EXPECT_EQ(result, true);
+        EXPECT_EQ(uint64Read, uint64Test);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_String_001
+ * @tc.desc: test serializer string read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_String_001, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const char stringWrite1[] = "asdfgh";
+    const char stringWrite2[] = "123456";
+    pid = fork();
+    if (pid < 0) {
+        return;
+    } else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteString(&io, stringWrite1);
+        EXPECT_EQ(result, true);
+        result = WriteString(&io, stringWrite2);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+
+        uint8_t* stringRead1 = nullptr;
+        size_t len;
+        stringRead1 = ReadString(&io, &len);
+        for (size_t i = 0; i < len; i++) {
+            EXPECT_EQ(stringWrite1[i], stringRead1[i]);
+        }
+        uint8_t* stringRead2 = nullptr;
+        stringRead2 = ReadString(&io, &len);
+        for (size_t i = 0; i < len; i++) {
+            EXPECT_EQ(stringWrite2[i], stringRead2[i]);
+        }
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_String_002
+ * @tc.desc: test serializer string read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_String_002, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    uint16_t str16Write[] = { 0x5634, 0x5635, 0x5636, 0x5637, 0x5638, 0x5639,
+    0x5640, 0x5641, 0x5642, 0x5643, 0x5644, 0x5645 };
+    size_t length = sizeof(str16Write) / sizeof(uint16_t);
+    pid = fork();
+    if (pid < 0) {
+        return;
+    } else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteString16(&io, str16Write, length);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+
+        uint16_t* str16Read = nullptr;
+        str16Read = ReadString16(&io, &length);
+        for (size_t i = 0; i < length; i++) {
+            EXPECT_EQ(str16Write[i], str16Read[i]);
+        }
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Float_001
+ * @tc.desc: test serializer float and double types read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Float_001, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    float floatWrite = 12.345678f;
+    double doubleWrite = 1345.7653;
+    pid = fork();
+    if (pid < 0) {
+        return;
+    } else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteFloat(&io, floatWrite);
+        EXPECT_EQ(result, true);
+        result = WriteDouble(&io, doubleWrite);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+
+        float floatRead;
+        result = ReadFloat(&io, &floatRead);
+        EXPECT_EQ(result, true);
+        EXPECT_EQ(floatWrite, floatRead);
+        double doubleRead;
+        result = ReadDouble(&io, &doubleRead);
+        EXPECT_EQ(doubleWrite, doubleRead);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_Data_Structure_001
+ * @tc.desc: test serializer struct data related function.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_Data_Structure_001, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const struct Padded pad = { 'p', 0x34567890, 0x2345678998765432 };
+    const struct Unpadded unpad = { 'u' };
+    pid = fork();
+    if (pid < 0) {
+        return;
+    } else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+        result = WriteBuffer(&io, static_cast<const void*>(&pad), sizeof(struct Padded));
+        EXPECT_EQ(true, result);
+        result = WriteBuffer(&io, static_cast<const void*>(&unpad), sizeof(struct Unpadded));
+        EXPECT_EQ(true, result);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        const struct Padded* padRead = reinterpret_cast<const struct Padded*>(ReadBuffer(&io, sizeof(struct Padded)));
+        EXPECT_EQ(pad.title, padRead->title);
+        EXPECT_EQ(pad.handle, padRead->handle);
+        EXPECT_EQ(pad.cookie, padRead->cookie);
+        const struct Unpadded* unpadRead =
+            reinterpret_cast<const struct Unpadded *>(ReadBuffer(&io, sizeof(struct Unpadded)));
+        EXPECT_EQ(unpad.tip, unpadRead->tip);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndReadVector_Bool_001
+ * @tc.desc: test bool vector serializer write and read.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndReadVector_Bool_001, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const bool boolTest[12] = { true, false, false, true, false, false, true, false, true, true, false, true };
+    size_t sizeBool = sizeof(boolTest) / sizeof(bool);
+    pid = fork();
+    if (pid < 0) {
+        return;
+    } else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteBoolVector(&io, boolTest, sizeBool);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+
+        bool* boolRead = nullptr;
+        size_t readLen = 0;
+        boolRead = ReadBoolVector(&io, &readLen);
+        EXPECT_EQ(readLen, sizeBool);
+        for (size_t i = 0; i < readLen; i++) {
+            EXPECT_EQ(boolTest[i], boolRead[i]);
+        }
+        free(boolRead);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_Vector_001
+ * @tc.desc: test int8_t and int16_t vector serializer write and read.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_Vector_001, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const int8_t int8Test[12] = { -0x27, -0x28, -0x29, -0x30, 0x31, 0x32, -0x33, -0x34, -0x35, -0x36, -0x37, -0x38 };
+    size_t sizeInt8 = sizeof(int8Test) / sizeof(int8_t);
+    const int16_t int16Test[12] = { 0x1234, -0x2345, 0x3456, -0x4567, 0x5678,
+    -0x1235, 0x1236, 0x1237, 0x1238, -0x1239, 0x1240, 0x1241 };
+    size_t sizeInt16 = sizeof(int16Test) / sizeof(int16_t);
+    pid = fork();
+    if (pid == 0) {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteInt8Vector(&io, int8Test, sizeInt8);
+        EXPECT_EQ(result, true);
+        result = WriteInt16Vector(&io, int16Test, sizeInt16);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        int8_t* int8Read = nullptr;
+        size_t readLen = 0;
+        int8Read = ReadInt8Vector(&io, &readLen);
+        EXPECT_EQ(readLen, sizeInt8);
+        for (size_t i = 0; i < readLen; i++) {
+            EXPECT_EQ(int8Test[i], int8Read[i]);
+        }
+        int16_t* int16Read = nullptr;
+        int16Read = ReadInt16Vector(&io, &readLen);
+        EXPECT_EQ(readLen, sizeInt16);
+        for (size_t i = 0; i < readLen; i++) {
+            EXPECT_EQ(int16Test[i], int16Read[i]);
+        }
+        free(int16Read);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_Vector_002
+ * @tc.desc: test int32_t and int64_t vector serializer write and read.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_Vector_002, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const int32_t int32Test[12] = { 0x12345678, -0x23456789, 0x34567890, -0x45678901, 0x12345778, 0x12345878,
+    -0x12345978, 0x12345878, -0x12345818, 0x12345828, 0x12345838, 0x12345848 };
+    size_t sizeInt32 = sizeof(int32Test) / sizeof(int32_t);
+    const int64_t int64Test[12] = { 0x1234567887654321, -0x2345678998765432, 0x1234567887654300,
+    0x1234567887654301, 0x1234567887654302, 0x1234567887654303, -0x1234567887654304, 0x1234567887654305,
+    0x1234567887654306, 0x1234567887654307, 0x1234567887654308, 0x1234567887654309 };
+    size_t sizeInt64 = sizeof(int64Test) / sizeof(int64_t);
+    pid = fork();
+    if (pid == 0) {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteInt32Vector(&io, int32Test, sizeInt32);
+        EXPECT_EQ(result, true);
+        result = WriteInt64Vector(&io, int64Test, sizeInt64);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        size_t readLen = 0;
+        int32_t* int32Read = nullptr;
+        int32Read = ReadInt32Vector(&io, &readLen);
+        EXPECT_EQ(readLen, sizeInt32);
+        for (size_t i = 0; i < readLen; i++) {
+            EXPECT_EQ(int32Test[i], int32Read[i]);
+        }
+        int64_t* int64Read = nullptr;
+        int64Read = ReadInt64Vector(&io, &readLen);
+        EXPECT_EQ(readLen, sizeInt64);
+        for (size_t i = 0; i < readLen; i++) {
+            EXPECT_EQ(int64Test[i], int64Read[i]);
+        }
+        close(fd[0]);
+    }
+}
+/**
+ * @tc.name: test_serializer_Vector_003
+ * @tc.desc: test uint8_t and uint16_t vector serializer write and read.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_Vector_003, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const uint8_t uint8Test[12] = { 0x01, 0x10, 0x20, 0x30, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47 };
+    size_t sizeUint8 = sizeof(uint8Test) / sizeof(uint8_t);
+    const uint16_t uint16Test[12] = { 0x1234, 0x2345, 0x3456, 0x4567, 0x5678, 0x1235, 0x1236,
+    0x1237, 0x1238, 0x1239, 0x1240, 0x1241 };
+    size_t sizeUint16 = sizeof(uint16Test) / sizeof(uint16_t);
+    pid = fork();
+    if (pid == 0) {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteUInt8Vector(&io, uint8Test, sizeUint8);
+        EXPECT_EQ(result, true);
+        result = WriteUInt16Vector(&io, uint16Test, sizeUint16);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        size_t readLen = 0;
+        uint8_t* uint8Read = nullptr;
+        uint8Read = ReadUInt8Vector(&io, &readLen);
+        EXPECT_EQ(readLen, sizeUint8);
+        for (size_t i = 0; i < readLen; i++) {
+        EXPECT_EQ(uint8Test[i], uint8Read[i]);
+        }
+        uint16_t* uint16Read = nullptr;
+        uint16Read = ReadUInt16Vector(&io, &readLen);
+        EXPECT_EQ(readLen, sizeUint16);
+        for (size_t i = 0; i < readLen; i++) {
+            EXPECT_EQ(uint16Test[i], uint16Read[i]);
+        }
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_Vector_004
+ * @tc.desc: test int32_t and int64_t tvector serializer write and read.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_Vector_004, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const uint32_t uint32Test[12] = { 0x12345678, 0x23456789, 0x34567890, 0x45678901, 0x12345778, 0x12345878,
+    0x12345978, 0x12345878, 0x12345818, 0x12345828, 0x12345838, 0x12345848 };
+    size_t sizeUint32 = sizeof(uint32Test) / sizeof(uint32_t);
+    const uint64_t uint64Test[12] = { 0x1234567887654321, 0x2345678998765432, 0x1234567887654300, 0x1234567887654301,
+    0x1234567887654302, 0x1234567887654303, 0x1234567887654304, 0x1234567887654305, 0x1234567887654306,
+    0x1234567887654307, 0x1234567887654308, 0x1234567887654309 };
+    size_t sizeUint64 = sizeof(uint64Test) / sizeof(uint64_t);
+    pid = fork();
+    if (pid == 0) {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteUInt32Vector(&io, uint32Test, sizeUint32);
+        EXPECT_EQ(result, true);
+        result = WriteUInt64Vector(&io, uint64Test, sizeUint64);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        size_t readLen = 0;
+        uint32_t* uint32Read = nullptr;
+        uint32Read = ReadUInt32Vector(&io, &readLen);
+        EXPECT_EQ(readLen, sizeUint32);
+        for (size_t i = 0; i < readLen; i++) {
+            EXPECT_EQ(uint32Test[i], uint32Read[i]);
+        }
+        uint64_t* uint64Read = nullptr;
+        uint64Read = ReadUInt64Vector(&io, &readLen);
+        EXPECT_EQ(readLen, sizeUint64);
+        for (size_t i = 0; i < readLen; i++) {
+            EXPECT_EQ(uint64Test[i], uint64Read[i]);
+        }
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_Vector_005
+ * @tc.desc: test vector serializer read and write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_Vector_005, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const float floatTest[12] = { 11221.132313, 11221.45678, 11221.45608, 11221.45618, 11221.45628,
+    11221.45638, 11221.45648, 11221.45658, 11221.45668, 11221.45678, 11221.45688, 11221.45698 };
+    size_t sizeFloat = sizeof(floatTest) / sizeof(float);
+    const double doubleTest[12] = { 1122.132313, 1122.45678, 1122.45678, 1122.45660, 1122.45661, 1122.45662,
+    1122.45663, 1122.45664, 1122.456765, 1122.45666, 1122.45667, 1122.45668 };
+    size_t sizeDouble = sizeof(doubleTest) / sizeof(double);
+    pid = fork();
+    if (pid == 0) {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteFloatVector(&io, floatTest, sizeFloat);
+        EXPECT_EQ(result, true);
+        result = WriteDoubleVector(&io, doubleTest, sizeDouble);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        float* floatRead = nullptr;
+        floatRead = ReadFloatVector(&io, &sizeFloat);
+        for (size_t i = 0; i < sizeFloat; i++) {
+            EXPECT_EQ(floatTest[i], floatRead[i]);
+        }
+        double* doubleRead = nullptr;
+        doubleRead = ReadDoubleVector(&io, &sizeDouble);
+        for (size_t i = 0; i < sizeDouble; i++) {
+            EXPECT_EQ(doubleTest[i], doubleRead[i]);
+        }
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_String_003
+ * @tc.desc: test string serializer read and write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_String_003, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const uint16_t interfaceTest[] = { 0x5634, 0x5635, 0x5636, 0x5637, 0x5638, 0x5639,
+    0x5640, 0x5641, 0x5642, 0x5643, 0x5644, 0x5645 };
+    size_t len = sizeof(interfaceTest) / sizeof(uint16_t);
+    const double doubleTest[12] = { 1122.132313, 1122.45678, 1122.45678, 1122.45660, 1122.45661,
+    1122.45662, 1122.45663, 1122.45664, 1122.456765, 1122.45666, 1122.45667, 1122.45668 };
+    size_t sizeDouble = sizeof(doubleTest) / sizeof(double);
+    pid = fork();
+    if (pid == 0) {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteInterfaceToken(&io, interfaceTest, len);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        uint16_t* interfaceRead = nullptr;
+        size_t length;
+        interfaceRead = ReadInterfaceToken(&io, &length);
+        for (size_t i = 0; i < length; i++) {
+            EXPECT_EQ(interfaceTest[i], interfaceRead[i]);
+        }
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_String_004
+ * @tc.desc: test string serializer read and write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_String_004, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    const struct Padded testData = { 'p', 0x34567890, 0x2345678998765432 };
+    size_t size = sizeof(struct Padded);
+    const double doubleTest[12] = { 1122.132313, 1122.45678, 1122.45678, 1122.45660, 1122.45661, 1122.45662,
+    1122.45663, 1122.45664, 1122.456765, 1122.45666, 1122.45667, 1122.45668 };
+    size_t sizeDouble = sizeof(doubleTest) / sizeof(double);
+    pid = fork();
+    if (pid == 0) {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteRawData(&io, &testData, size);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        struct Padded* dataRead = nullptr;
+        dataRead = reinterpret_cast<struct Padded*>(ReadRawData(&io, sizeof(struct Padded)));
+        EXPECT_EQ(testData.title, dataRead->title);
+        EXPECT_EQ(testData.handle, dataRead->handle);
+        EXPECT_EQ(testData.cookie, dataRead->cookie);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Pointer_001
+ * @tc.desc: test pointer serializer read and write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Pointer_001, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    char* testData = "sjf";
+    pid = fork();
+    if (pid == 0) {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WritePointer(&io, (uintptr_t)testData);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        uintptr_t valueRead = ReadPointer(&io);
+        EXPECT_EQ(0, strcmp(testData, (char*)valueRead));
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_threshold_001
+ * @tc.desc: test threshold serializer read and write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_threshold_001, TestSize.Level0)
+{
+    IpcIo io;
+    uint8_t buffer[SMALL_BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, SMALL_BUFFER_SIZE, 0);
+    const char* strwrite ="test for write string threshold********************************************************\
+    #####################################################";
+                       
+    bool result = WriteString(&io, strwrite);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_ioUninitialized_001
+ * @tc.desc: test io uninitialized serializer read and write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_ioUninitialized_001, TestSize.Level0)
+{
+    IpcIo io;
+    bool boolTest = false;
+    bool result = WriteBool(&io, boolTest);
+    EXPECT_EQ(result, false);
+
+    int8_t int8Test = -0x34;
+    result = WriteInt8(&io, int8Test);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Maximum_001
+ * @tc.desc: test serializer Maximum of primary type read write.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Maximum_001, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    struct TestData data = { true, 0x7F, 0x7FFF, 0x7FFFFFFF, 0xFF, 0xFFFF, 0xFFFFFFFF };
+    pid = fork();
+    if (pid < 0) {
+        return;
+    } else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        WriteTestData(&io, data);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        ReadTestData(&io, data);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Maximum_002
+ * @tc.desc: test serializer Maximum of primary type read write.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Maximum_002, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        perror("pipe error!\n");
+        return;
+    }
+    bool result;
+    struct TestData data = { true, 0x7F, 0x7FFF, 0x7FFFFFFF, 0xFF, 0xFFFF, 0xFFFFFFFF };
+    pid = fork();
+    if (pid < 0) {
+        return;
+    }
+    else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        WriteTestDataUnaligned(&io, data);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        ReadTestDataUnaligned(&io, data);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Maximum_003
+ * @tc.desc: test serializer primary type read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Maximum_003, TestSize.Level0)
+{
+    uint8_t buffer[BUFFER_SIZE] = {0};
+    int pid = -1;
+    int ret = -1;
+    int fd[2];
+    if (pipe(fd) < 0) {
+        return;
+    }
+    bool result;
+    int64_t int64Test = 0x7FFFFFFFFFFFFFFF;
+    uint64_t uint64Test = 0xFFFFFFFFFFFFFFFF;
+    pid = fork();
+    if (pid < 0) {
+        return;
+    } else if (pid == 0) {
+        close(fd[0]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        result = WriteInt64(&io, int64Test);
+        EXPECT_EQ(result, true);
+        result = WriteUint64(&io, uint64Test);
+        EXPECT_EQ(result, true);
+        ret = write(fd[1], buffer, io.bufferCur - io.bufferBase);
+        sleep(1);
+        close(fd[1]);
+        _exit(pid);
+    } else {
+        close(fd[1]);
+        IpcIo io;
+        IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+        sleep(2);
+        ret = read(fd[0], buffer, BUFFER_SIZE);
+        int64_t int64Read;
+        result = ReadInt64(&io, &int64Read);
+        EXPECT_EQ(result, true);
+        EXPECT_EQ(int64Read, int64Test);
+        uint64_t uint64Read;
+        result = ReadUint64(&io, &uint64Read);
+        EXPECT_EQ(result, true);
+        EXPECT_EQ(uint64Read, uint64Test);
+        close(fd[0]);
+    }
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_String_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_String_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const char *stringWrite = nullptr;
+    bool result = WriteString(&io, stringWrite);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_String16_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_String16_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    uint16_t str16Write[] = {};
+    size_t length = sizeof(str16Write) / sizeof(uint16_t);
+    bool result = WriteString16(&io, str16Write, length);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_Buffer_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_Buffer_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    struct Padded pad;
+    bool result = WriteBuffer(&io, static_cast<const void*>(&pad), 0);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_InterfaceToken_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_InterfaceToken_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const uint16_t interfaceTest[] = {};
+    size_t len = sizeof(interfaceTest) / sizeof(uint16_t);
+    bool result = WriteInterfaceToken(&io, interfaceTest, len);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_RawData_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_RawData_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    struct Padded rawDataTest;
+    bool result = WriteRawData(&io, &rawDataTest, 0);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_BoolVector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_BoolVector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const bool boolTest[] = {};
+    size_t sizeBool = sizeof(boolTest) / sizeof(bool);
+    bool result = WriteBoolVector(&io, boolTest, sizeBool);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_Int8Vector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_Int8Vector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const int8_t int8Test[] = {};
+    size_t sizeInt8 = sizeof(int8Test) / sizeof(int8_t);
+    bool result = WriteInt8Vector(&io, int8Test, sizeInt8);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_Int16Vector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_Int16Vector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const int16_t int16Test[] = {};
+    size_t sizeInt16 = sizeof(int16Test) / sizeof(int16_t);
+    bool result = WriteInt16Vector(&io, int16Test, sizeInt16);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_Int32Vector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_Int32Vector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const int32_t int32Test[] = {};
+    size_t sizeInt32 = sizeof(int32Test) / sizeof(int32_t);
+    bool result = WriteInt32Vector(&io, int32Test, sizeInt32);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_Int64Vector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_Int64Vector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const int64_t int64Test[] = {};
+    size_t sizeInt64 = sizeof(int64Test) / sizeof(int64_t);
+    bool result = WriteInt64Vector(&io, int64Test, sizeInt64);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_UInt8Vector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_UInt8Vector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const uint8_t uint8Test[] = {};
+    size_t sizeUint8 = sizeof(uint8Test) / sizeof(uint8_t);
+    bool result = WriteUInt8Vector(&io, uint8Test, sizeUint8);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_UInt16Vector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_UInt16Vector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const uint16_t uint16Test[] = {};
+    size_t sizeUint16 = sizeof(uint16Test) / sizeof(uint16_t);
+    bool result = WriteUInt16Vector(&io, uint16Test, sizeUint16);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_UInt32Vector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_UInt32Vector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const uint32_t uint32Test[] = {};
+    size_t sizeUint32 = sizeof(uint32Test) / sizeof(uint32_t);
+    bool result = WriteUInt32Vector(&io, uint32Test, sizeUint32);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_UInt64Vector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_UInt64Vector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const uint64_t uint64Test[] = {};
+    size_t sizeUint64 = sizeof(uint64Test) / sizeof(uint64_t);
+    bool result = WriteUInt64Vector(&io, uint64Test, sizeUint64);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_FloatVector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_FloatVector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const float floatTest[] = {};
+    size_t sizeFloat = sizeof(floatTest) / sizeof(float);
+    bool result = WriteFloatVector(&io, floatTest, sizeFloat);
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: test_serializer_WriteAndRead_Abnormal_DoubleVector_001
+ * @tc.desc: test serializer Abnormal scene read write.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtilsSerializerTest, test_serializer_WriteAndRead_Abnormal_DoubleVector_001, TestSize.Level2)
+{
+    IpcIo io;
+    uint8_t buffer[BUFFER_SIZE] = { 0 };
+    IpcIoInit(&io, buffer, BUFFER_SIZE, 0);
+
+    const double doubleTest[] = {};
+    size_t sizeDouble = sizeof(doubleTest) / sizeof(double);
+    bool result = WriteDoubleVector(&io, doubleTest, sizeDouble);
+    EXPECT_EQ(result, false);
+}