diff --git a/interfaces/test/unittest/filemgmt_libn_test/BUILD.gn b/interfaces/test/unittest/filemgmt_libn_test/BUILD.gn
index ea20a1cf9f7b571e107d8d534852829741ebf3bb..88d7ba73ce0e6cf0b38929b7017c38536e41678f 100644
--- a/interfaces/test/unittest/filemgmt_libn_test/BUILD.gn
+++ b/interfaces/test/unittest/filemgmt_libn_test/BUILD.gn
@@ -1,4 +1,4 @@
-# Copyright (C) 2023 Huawei Device Co., Ltd.
+# Copyright (C) 2023-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
@@ -20,15 +20,20 @@ group("unittest") {
 }
 
 ohos_unittest("filemgmt_libn_test") {
+  testonly = true
+
   module_out_path = "file_api/file_api"
   include_dirs = [ "./include" ]
 
-  sources = [ "./src/n_class_test.cpp" ]
+  sources = [
+    "./src/n_val_test.cpp",
+    "./src/nval_mock.cpp",
+  ]
 
   deps = [
     "${utils_path}/filemgmt_libhilog:filemgmt_libhilog",
     "${utils_path}/filemgmt_libn:filemgmt_libn",
-    "//third_party/googletest:gtest_main",
+    "//third_party/googletest:gmock_main",
   ]
 
   external_deps = [
@@ -39,4 +44,6 @@ ohos_unittest("filemgmt_libn_test") {
     "ipc:ipc_core",
     "napi:ace_napi",
   ]
+
+  cflags_cc = [ "-DENABLE_NAPI_MOCK" ]
 }
diff --git a/interfaces/test/unittest/filemgmt_libn_test/include/nval_mock.h b/interfaces/test/unittest/filemgmt_libn_test/include/nval_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..5aace893b1bbaa81702767d64e24594fa89f5ebe
--- /dev/null
+++ b/interfaces/test/unittest/filemgmt_libn_test/include/nval_mock.h
@@ -0,0 +1,206 @@
+/*
+* 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.
+*/
+
+#ifndef INTERFACES_TEST_UNITTEST_FILEMGMT_LIBN_TEST_INCLUDE_NAPI_MOCK_H
+#define INTERFACES_TEST_UNITTEST_FILEMGMT_LIBN_TEST_INCLUDE_NAPI_MOCK_H
+
+#pragma once
+#include <gmock/gmock.h>
+#include "n_napi.h"
+#include "n_val.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace LibN {
+namespace Test {
+
+class INValMock {
+public:
+    virtual ~INValMock() = default;
+
+    virtual napi_status napi_get_undefined(napi_env env, napi_value* result) = 0;
+
+    virtual napi_status napi_create_bigint_int64(napi_env env, int64_t value, napi_value* result) = 0;
+
+    virtual napi_status napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result) = 0;
+
+    virtual napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result) = 0;
+
+    virtual napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result) = 0;
+
+    virtual napi_status napi_create_uint32(napi_env env, uint32_t value, napi_value* result) = 0;
+
+    virtual napi_status napi_create_object(napi_env env, napi_value* result) = 0;
+
+    virtual napi_status napi_get_boolean(napi_env env, bool value, napi_value* result) = 0;
+
+    virtual napi_status napi_create_string_utf8(napi_env env, const char* str, size_t length, napi_value* result) = 0;
+
+    virtual napi_status napi_create_external_arraybuffer(napi_env env, void* external_data,
+        size_t byte_length, napi_finalize finalize_cb, void* finalize_hint, napi_value* result) = 0;
+    
+    virtual napi_status napi_create_typedarray(napi_env env, napi_typedarray_type type,
+        size_t length, napi_value arraybuffer, size_t byte_offset, napi_value* result) = 0;
+
+    virtual napi_status napi_create_array(napi_env env, napi_value* result) = 0;
+
+    virtual napi_status napi_set_element(napi_env env, napi_value object, uint32_t index, napi_value value) = 0;
+
+    virtual napi_status napi_create_arraybuffer(napi_env env, size_t byte_length, void** data, napi_value* result) = 0;
+
+    virtual napi_status napi_get_value_string_utf8(
+        napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result) = 0;
+
+    virtual napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result) = 0;
+
+    virtual napi_status napi_get_value_string_utf16(
+        napi_env env, napi_value value, char16_t* buf, size_t bufsize, size_t* result) = 0;
+
+    virtual napi_status napi_is_error(napi_env env, napi_value value, bool* result) = 0;
+
+    virtual napi_status napi_get_value_external(napi_env env, napi_value value, void** result) = 0;
+
+    virtual napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result) = 0;
+
+    virtual napi_status napi_get_value_int32(napi_env env, napi_value value, int32_t* result) = 0;
+
+    virtual napi_status napi_get_value_uint32(napi_env env, napi_value value, uint32_t* result) = 0;
+
+    virtual napi_status napi_get_value_int64(napi_env env, napi_value value, int64_t* result) = 0;
+
+    virtual napi_status napi_get_value_double(napi_env env, napi_value value, double* result) = 0;
+
+    virtual napi_status napi_get_value_bigint_uint64(
+        napi_env env, napi_value value, uint64_t* result, bool* lossless) = 0;
+
+    virtual napi_status napi_get_array_length(napi_env env, napi_value value, uint32_t* result) = 0;
+
+    virtual napi_status napi_get_arraybuffer_info(
+        napi_env env, napi_value arraybuffer, void** data, size_t* byte_length) = 0;
+
+    virtual napi_status napi_get_typedarray_info(
+        napi_env env,  napi_value typedarray,  napi_typedarray_type* type,
+        size_t* length, void** data, napi_value* arraybuffer, size_t* byte_offset) = 0;
+
+    virtual napi_status napi_has_named_property(
+        napi_env env, napi_value object, const char* utf8name, bool* result) = 0;
+};
+
+class NValMock : public INValMock {
+public:
+    MOCK_METHOD(napi_status, napi_get_undefined, (napi_env env, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_bigint_int64, (napi_env env, int64_t value, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_bigint_uint64, (napi_env env, uint64_t value, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_int64, (napi_env env, int64_t value, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_int32, (napi_env env, int32_t value, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_uint32, (napi_env env, uint32_t value, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_object, (napi_env env, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_boolean, (napi_env env, bool value, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_string_utf8, (napi_env env,
+        const char* str, size_t length, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_external_arraybuffer, (napi_env env, void* external_data,
+        size_t byte_length, napi_finalize finalize_cb, void* finalize_hint, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_typedarray, (napi_env env, napi_typedarray_type type,
+        size_t length, napi_value arraybuffer, size_t byte_offset, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_create_array, (napi_env env, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_set_element,
+        (napi_env env, napi_value object, uint32_t index, napi_value value), (override));
+
+    MOCK_METHOD(napi_status, napi_create_arraybuffer,
+        (napi_env env, size_t byte_length, void** data, napi_value* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_value_string_utf8,
+        (napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result), (override));
+
+    MOCK_METHOD(napi_status, napi_typeof, (napi_env env, napi_value value, napi_valuetype* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_value_string_utf16,
+        (napi_env env, napi_value value, char16_t* buf, size_t bufsize, size_t* result), (override));
+
+    MOCK_METHOD(napi_status, napi_is_error, (napi_env env, napi_value value, bool* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_value_external, (napi_env env, napi_value value, void** result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_value_bool, (napi_env env, napi_value value, bool* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_value_int32, (napi_env env, napi_value value, int32_t* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_value_uint32, (napi_env env, napi_value value, uint32_t* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_value_int64, (napi_env env, napi_value value, int64_t* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_value_double, (napi_env env, napi_value value, double* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_value_bigint_uint64,
+        (napi_env env, napi_value value, uint64_t* result, bool* lossless), (override));
+
+    MOCK_METHOD(napi_status, napi_get_array_length, (napi_env env, napi_value value, uint32_t* result), (override));
+
+    MOCK_METHOD(napi_status, napi_get_arraybuffer_info,
+        (napi_env env, napi_value arraybuffer, void** data, size_t* byte_length), (override));
+
+    MOCK_METHOD(napi_status, napi_get_typedarray_info,
+        (napi_env env,  napi_value typedarray,  napi_typedarray_type* type,
+        size_t* length, void** data, napi_value* arraybuffer, size_t* byte_offset), (override));
+
+    MOCK_METHOD(napi_status, napi_has_named_property,
+        (napi_env env, napi_value object, const char* utf8name, bool* result), (override));
+};
+
+NValMock &GetNValMock();
+void SetNValMock(NValMock *mock);
+void ResetNValMock();
+
+class ScopedNValMock {
+public:
+    explicit ScopedNValMock(NValMock *mock) : mock_(mock)
+    {
+        SetNValMock(mock_);
+    }
+
+    ~ScopedNValMock()
+    {
+        ResetNValMock();
+    }
+
+    NValMock &GetMock()
+    {
+        return *mock_;
+    }
+
+    ScopedNValMock(const ScopedNValMock &) = delete;
+    ScopedNValMock &operator=(const ScopedNValMock &) = delete;
+
+private:
+    NValMock *mock_;
+};
+
+} // namespace Test
+} // namespace LibN
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_TEST_UNITTEST_FILEMGMT_LIBN_TEST_INCLUDE_NAPI_MOCK_H
\ No newline at end of file
diff --git a/interfaces/test/unittest/filemgmt_libn_test/src/n_val_test.cpp b/interfaces/test/unittest/filemgmt_libn_test/src/n_val_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0a686c82a40895e98f69e24788d7ef9a3729e818
--- /dev/null
+++ b/interfaces/test/unittest/filemgmt_libn_test/src/n_val_test.cpp
@@ -0,0 +1,1414 @@
+/*
+* Copyright (C) 2023-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 <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "n_val.h"
+#include "nval_mock.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace LibN {
+namespace Test {
+using namespace std;
+
+class NValTest : public testing::Test {
+public:
+    static void SetUpTestSuite(void) {}
+    static void TearDownTestSuite(void) {}
+
+    void SetUp() override
+    {
+        mock_ = std::make_unique<NValMock>();
+        scopedMock_ = std::make_unique<ScopedNValMock>(mock_.get());
+    }
+
+    void TearDown() override
+    {
+        scopedMock_.reset();
+        mock_.reset();
+    }
+
+    NValMock &GetMock()
+    {
+        return *mock_;
+    }
+
+private:
+    std::unique_ptr<NValMock> mock_;
+    std::unique_ptr<ScopedNValMock> scopedMock_;
+};
+
+/**
+* @tc.name: NValTest_CreateUndefined_001
+* @tc.desc: Test function of NVal::CreateUndefined interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateUndefined_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateUndefined_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_get_undefined(testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<1>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateUndefined(env);
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateUndefined_001";
+}
+
+/**
+* @tc.name: NValTest_CreateBigInt64_001
+* @tc.desc: Test function of NVal::CreateBigInt64 interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateBigInt64_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateBigInt64_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_bigint_int64(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateBigInt64(env, 0);
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateBigInt64_001";
+}
+
+/**
+* @tc.name: NValTest_CreateBigIntUint64_001
+* @tc.desc: Test function of NVal::CreateBigIntUint64 interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateBigIntUint64_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateBigIntUint64_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_bigint_uint64(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateBigIntUint64(env, 0);
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateBigIntUint64_001";
+}
+
+/**
+* @tc.name: NValTest_CreateInt64_001
+* @tc.desc: Test function of NVal::CreateInt64 interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateInt64_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateInt64_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_int64(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateInt64(env, 0);
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateInt64_001";
+}
+
+/**
+* @tc.name: NValTest_CreateInt32_001
+* @tc.desc: Test function of NVal::CreateInt32 interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateInt32_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateInt32_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_int32(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateInt32(env, 0);
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateInt32_001";
+}
+
+/**
+* @tc.name: NValTest_CreateUint32_001
+* @tc.desc: Test function of NVal::CreateUint32 interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateUint32_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateUint32_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_uint32(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateUint32(env, 0);
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateUint32_001";
+}
+
+/**
+* @tc.name: NValTest_CreateObject_001
+* @tc.desc: Test function of NVal::CreateObject interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateObject_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateObject_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_object(testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<1>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateObject(env);
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateObject_001";
+}
+
+/**
+* @tc.name: NValTest_CreateBool_001
+* @tc.desc: Test function of NVal::CreateBool interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateBool_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateBool_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_get_boolean(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateBool(env, true);
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateBool_001";
+}
+
+/**
+* @tc.name: NValTest_CreateUTF8String_001
+* @tc.desc: Test function of NVal::CreateUTF8String interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateUTF8String_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateUTF8String_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    string entity = "NValTest_CreateUTF8String_001";
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_string_utf8(testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<3>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateUTF8String(env, entity);
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateUTF8String_001";
+}
+
+/**
+* @tc.name: NValTest_CreateUTF8String_002
+* @tc.desc: Test function of NVal::CreateUTF8String interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateUTF8String_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateUTF8String_002";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    string entity = "NValTest_CreateUTF8String_002";
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_string_utf8(testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<3>(res), testing::Return(napi_ok)));
+
+    auto [envRes, val] = NVal::CreateUTF8String(env, entity.c_str(), entity.length());
+    EXPECT_EQ(val, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateUTF8String_002";
+}
+
+/**
+* @tc.name: NValTest_CreateUint8Array_001
+* @tc.desc: Test function of NVal::CreateUint8Array interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateUint8Array_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateUint8Array_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    string entity = "NValTest_CreateUint8Array_001";
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_external_arraybuffer(
+        testing::_, testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(napi_ok));
+    EXPECT_CALL(GetMock(), napi_create_typedarray(
+        testing::_, testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<5>(res), testing::Return(napi_ok)));
+
+    auto [envRes, output_array] = NVal::CreateUint8Array(
+        env, const_cast<void*>(static_cast<const void*>(entity.c_str())), entity.length());
+    EXPECT_EQ(output_array, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateUint8Array_001";
+}
+
+/**
+* @tc.name: NValTest_CreateArrayString_001
+* @tc.desc: Test function of NVal::CreateArrayString interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateArrayString_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateArrayString_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    vector<string> entity = {"NValTest", "CreateArrayString"};
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    EXPECT_CALL(GetMock(), napi_create_array(testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<1>(res), testing::Return(napi_ok)));
+    EXPECT_CALL(GetMock(), napi_create_string_utf8(testing::_, testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::Return(napi_ok));
+    EXPECT_CALL(GetMock(), napi_set_element(testing::_, testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::Return(napi_ok));
+
+    auto [envRes, output_array] = NVal::CreateArrayString(env, entity);
+    EXPECT_EQ(output_array, res);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateArrayString_001";
+}
+
+/**
+* @tc.name: NValTest_CreateArrayBuffer_001
+* @tc.desc: Test function of NVal::CreateArrayBuffer interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_CreateArrayBuffer_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_CreateArrayBuffer_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    string str = "NValTest_CreateArrayBuffer_001";
+    size_t len = str.length();
+
+    napi_value res = reinterpret_cast<napi_value>(0x1234);
+    void * buf = const_cast<void*>(static_cast<const void*>(str.c_str()));
+    EXPECT_CALL(GetMock(), napi_create_arraybuffer(testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(
+        testing::SetArgPointee<2>(buf), testing::SetArgPointee<3>(res), testing::Return(napi_ok)));
+
+    auto [ret, buffer] = NVal::CreateArrayBuffer(env, len);
+    auto [envRes, val] = ret;
+    EXPECT_EQ(val, res);
+    EXPECT_TRUE(buffer);
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_CreateArrayBuffer_001";
+}
+
+/**
+* @tc.name: NValTest_DeclareNapiProperty_001
+* @tc.desc: Test function of NVal::DeclareNapiProperty interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_DeclareNapiProperty_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_DeclareNapiProperty_001";
+    string str = "NValTest_DeclareNapiProperty_001";
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+
+    auto res = NVal::DeclareNapiProperty(str.c_str(), val);
+
+    EXPECT_EQ(res.utf8name, str.c_str());
+    EXPECT_EQ(res.name, nullptr);
+    EXPECT_EQ(res.method, nullptr);
+    EXPECT_EQ(res.getter, nullptr);
+    EXPECT_EQ(res.setter, nullptr);
+    EXPECT_EQ(res.value, val);
+    EXPECT_EQ(res.attributes, napi_default);
+    EXPECT_EQ(res.data, nullptr);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_DeclareNapiProperty_001";
+}
+
+/**
+* @tc.name: NValTest_DeclareNapiStaticProperty_001
+* @tc.desc: Test function of NVal::DeclareNapiStaticProperty interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_DeclareNapiStaticProperty_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_DeclareNapiStaticProperty_001";
+    string str = "NValTest_DeclareNapiStaticProperty_001";
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+
+    auto res = NVal::DeclareNapiStaticProperty(str.c_str(), val);
+
+    EXPECT_EQ(res.utf8name, str.c_str());
+    EXPECT_EQ(res.name, nullptr);
+    EXPECT_EQ(res.method, nullptr);
+    EXPECT_EQ(res.getter, nullptr);
+    EXPECT_EQ(res.setter, nullptr);
+    EXPECT_EQ(res.value, val);
+    EXPECT_EQ(res.attributes, napi_static);
+    EXPECT_EQ(res.data, nullptr);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_DeclareNapiStaticProperty_001";
+}
+
+/**
+* @tc.name: NValTest_DeclareNapiFunction_001
+* @tc.desc: Test function of NVal::DeclareNapiFunction interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_DeclareNapiFunction_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_DeclareNapiFunction_001";
+    string str = "NValTest_DeclareNapiFunction_001";
+    napi_callback cal = reinterpret_cast<napi_callback>(0x1234);
+
+    auto res = NVal::DeclareNapiFunction(str.c_str(), cal);
+
+    EXPECT_EQ(res.utf8name, str.c_str());
+    EXPECT_EQ(res.name, nullptr);
+    EXPECT_EQ(res.method, cal);
+    EXPECT_EQ(res.getter, nullptr);
+    EXPECT_EQ(res.setter, nullptr);
+    EXPECT_EQ(res.value, nullptr);
+    EXPECT_EQ(res.attributes, napi_default);
+    EXPECT_EQ(res.data, nullptr);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_DeclareNapiFunction_001";
+}
+
+/**
+* @tc.name: NValTest_DeclareNapiStaticFunction_001
+* @tc.desc: Test function of NVal::DeclareNapiStaticFunction interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_DeclareNapiStaticFunction_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_DeclareNapiStaticFunction_001";
+    string str = "NValTest_DeclareNapiStaticFunction_001";
+    napi_callback cal = reinterpret_cast<napi_callback>(0x1234);
+
+    auto res = NVal::DeclareNapiStaticFunction(str.c_str(), cal);
+
+    EXPECT_EQ(res.utf8name, str.c_str());
+    EXPECT_EQ(res.name, nullptr);
+    EXPECT_EQ(res.method, cal);
+    EXPECT_EQ(res.getter, nullptr);
+    EXPECT_EQ(res.setter, nullptr);
+    EXPECT_EQ(res.value, nullptr);
+    EXPECT_EQ(res.attributes, napi_static);
+    EXPECT_EQ(res.data, nullptr);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_DeclareNapiStaticFunction_001";
+}
+
+/**
+* @tc.name: NValTest_DeclareNapiGetter_001
+* @tc.desc: Test function of NVal::DeclareNapiGetter interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_DeclareNapiGetter_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_DeclareNapiGetter_001";
+    string str = "NValTest_DeclareNapiGetter_001";
+    napi_callback getter = reinterpret_cast<napi_callback>(0x1234);
+
+    auto res = NVal::DeclareNapiGetter(str.c_str(), getter);
+
+    EXPECT_EQ(res.utf8name, str.c_str());
+    EXPECT_EQ(res.name, nullptr);
+    EXPECT_EQ(res.method, nullptr);
+    EXPECT_EQ(res.getter, getter);
+    EXPECT_EQ(res.setter, nullptr);
+    EXPECT_EQ(res.value, nullptr);
+    EXPECT_EQ(res.attributes, napi_default);
+    EXPECT_EQ(res.data, nullptr);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_DeclareNapiGetter_001";
+}
+
+/**
+* @tc.name: NValTest_DeclareNapiSetter_001
+* @tc.desc: Test function of NVal::DeclareNapiSetter interface for SUCCESS.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_DeclareNapiSetter_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_DeclareNapiSetter_001";
+    string str = "NValTest_DeclareNapiSetter_001";
+    napi_callback setter = reinterpret_cast<napi_callback>(0x1234);
+
+    auto res = NVal::DeclareNapiSetter(str.c_str(), setter);
+
+    EXPECT_EQ(res.utf8name, str.c_str());
+    EXPECT_EQ(res.name, nullptr);
+    EXPECT_EQ(res.method, nullptr);
+    EXPECT_EQ(res.getter, nullptr);
+    EXPECT_EQ(res.setter, setter);
+    EXPECT_EQ(res.value, nullptr);
+    EXPECT_EQ(res.attributes, napi_default);
+    EXPECT_EQ(res.data, nullptr);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_DeclareNapiSetter_001";
+}
+
+/**
+* @tc.name: NValTest_ToUTF8String_001
+* @tc.desc: Test function of NVal::ToUTF8String interface for FAIL.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF8String_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF8String_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf8(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(napi_invalid_arg));
+
+    auto [succ, res, len] = n_val.ToUTF8String();
+    EXPECT_FALSE(succ);
+    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(len, 0);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF8String_001";
+}
+
+/**
+* @tc.name: NValTest_ToUTF8String_002
+* @tc.desc: Test function of NVal::ToUTF8String interface for FAIL.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF8String_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF8String_002";
+    size_t strLen = std::numeric_limits<size_t>::max();
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf8(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<4>(strLen), testing::Return(napi_ok)));
+
+    auto [succ, res, len] = n_val.ToUTF8String();
+    EXPECT_FALSE(succ);
+    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(len, 0);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF8String_002";
+}
+
+/**
+* @tc.name: NValTest_ToUTF8String_003
+* @tc.desc: Test function of NVal::ToUTF8String interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF8String_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF8String_003";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    string str = "NValTest_ToUTF8String_003";
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf8(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::Return(napi_ok));
+
+    auto [succ, res, len] = n_val.ToUTF8String();
+    EXPECT_TRUE(succ);
+    EXPECT_NE(res, nullptr);
+    EXPECT_EQ(len, 0);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF8String_003";
+}
+
+/**
+* @tc.name: NValTest_ToUTF8String_004
+* @tc.desc: Test function of NVal::ToUTF8String interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF8String_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF8String_004";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    string str = "NValTest_ToUTF8String_004";
+    napi_valuetype valueType = napi_function;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+
+    auto [succ, res, len] = n_val.ToUTF8String(str);
+    EXPECT_TRUE(succ);
+    EXPECT_NE(res, nullptr);
+    EXPECT_EQ(len, str.size());
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF8String_004";
+}
+
+/**
+* @tc.name: NValTest_ToUTF8String_005
+* @tc.desc: Test function of NVal::ToUTF8String interface for FIL.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF8String_005, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF8String_005";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    string str = "NValTest_ToUTF8String_005";
+    napi_valuetype valueType = napi_string;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf8(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(napi_invalid_arg));
+
+    auto [succ, res, len] = n_val.ToUTF8String(str);
+    EXPECT_FALSE(succ);
+    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(len, 0);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF8String_005";
+}
+
+/**
+* @tc.name: NValTest_ToUTF16String_001
+* @tc.desc: Test function of NVal::ToUTF16String interface for FAIL.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF16String_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF16String_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+
+#ifdef FILE_SUBSYSTEM_DEBUG_LOCAL
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf16(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(napi_invalid_arg));
+#else
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf8(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(napi_invalid_arg));
+#endif
+    auto [succ, res, len] = n_val.ToUTF16String();
+    EXPECT_FALSE(succ);
+    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(len, 0);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF16String_001";
+}
+
+/**
+* @tc.name: NValTest_ToUTF16String_002
+* @tc.desc: Test function of NVal::ToUTF16String interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF16String_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF16String_002";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+
+#ifdef FILE_SUBSYSTEM_DEBUG_LOCAL
+    string str = "NValTest_ToUTF16String_002";
+    size_t strLen = str.length();
+
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf16(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillOnce(testing::DoAll(testing::SetArgPointee<4>(strLen), testing::Return(napi_ok)))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(str), testing::Return(napi_ok)));
+
+    auto [succ, res, len] = n_val.ToUTF16String();
+    EXPECT_TRUE(succ);
+    EXPECT_NE(res, nullptr);
+    EXPECT_EQ(len, strLen);
+#else
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf8(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(napi_invalid_arg));
+
+    auto [succ, res, len] = n_val.ToUTF16String();
+    EXPECT_FALSE(succ);
+    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(len, 0);
+#endif
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF16String_002";
+}
+
+/**
+* @tc.name: NValTest_ToUTF8StringPath_001
+* @tc.desc: Test function of NVal::ToUTF8StringPath interface for FAIL.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF8StringPath_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF8StringPath_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf8(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::Return(napi_invalid_arg));
+
+    auto [succ, res, len] = n_val.ToUTF8StringPath();
+    EXPECT_FALSE(succ);
+    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(len, 0);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF8StringPath_001";
+}
+
+/**
+* @tc.name: NValTest_ToUTF8StringPath_002
+* @tc.desc: Test function of NVal::ToUTF8StringPath interface for FAIL.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF8StringPath_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF8StringPath_002";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+    string str = "NValTest_ToUTF8StringPath_002";
+    size_t strLen = str.length();
+
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf8(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillOnce(testing::DoAll(testing::SetArgPointee<4>(strLen), testing::Return(napi_ok)))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<4>(4096),
+        testing::Return(napi_ok)));
+
+    auto [succ, res, len] = n_val.ToUTF8StringPath();
+    EXPECT_FALSE(succ);
+    EXPECT_EQ(res, nullptr);
+    EXPECT_EQ(len, 0);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF8StringPath_002";
+}
+
+/**
+* @tc.name: NValTest_ToUTF8StringPath_003
+* @tc.desc: Test function of NVal::ToUTF8StringPath interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUTF8StringPath_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUTF8StringPath_003";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+    string str = "NValTest_ToUTF8StringPath_003";
+    size_t strLen = str.length();
+
+    EXPECT_CALL(GetMock(), napi_get_value_string_utf8(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillOnce(testing::DoAll(testing::SetArgPointee<4>(strLen), testing::Return(napi_ok)))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<4>(0), testing::Return(napi_ok)));
+
+    auto [succ, res, len] = n_val.ToUTF8StringPath();
+    EXPECT_TRUE(succ);
+    EXPECT_NE(res, nullptr);
+    EXPECT_EQ(len, 0);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUTF8StringPath_003";
+}
+
+/**
+* @tc.name: NValTest_TypeIs_001
+* @tc.desc: Test function of NVal::TypeIs interface for false.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_TypeIs_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_TypeIs_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+    napi_valuetype valueType = napi_string;
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+
+    bool succ = n_val.TypeIs(napi_undefined);
+    EXPECT_FALSE(succ);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_TypeIs_001";
+}
+
+/**
+* @tc.name: NValTest_TypeIs_002
+* @tc.desc: Test function of NVal::TypeIs interface for true.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_TypeIs_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_TypeIs_002";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+    napi_valuetype valueType = napi_string;
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+
+    bool succ = n_val.TypeIs(valueType);
+    EXPECT_TRUE(succ);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_TypeIs_002";
+}
+
+/**
+* @tc.name: NValTest_TypeIs_003
+* @tc.desc: Test function of NVal::TypeIs interface for false.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_TypeIs_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_TypeIs_003";
+    NVal n_val = NVal();
+    napi_valuetype valueType = napi_string;
+
+    bool succ = n_val.TypeIs(valueType);
+    EXPECT_FALSE(succ);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_TypeIs_003";
+}
+
+/**
+* @tc.name: NValTest_TypeIsError_001
+* @tc.desc: Test function of NVal::TypeIsError interface for false.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_TypeIsError_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_TypeIsError_001";
+    NVal n_val = NVal();
+
+    bool succ = n_val.TypeIsError(true);
+    EXPECT_FALSE(succ);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_TypeIsError_001";
+}
+
+/**
+* @tc.name: NValTest_TypeIsError_002
+* @tc.desc: Test function of NVal::TypeIsError interface for true.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_TypeIsError_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_TypeIsError_002";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+    bool res = true;
+
+    EXPECT_CALL(GetMock(), napi_is_error(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    bool succ = n_val.TypeIsError(res);
+    EXPECT_TRUE(succ);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_TypeIsError_002";
+}
+
+/**
+* @tc.name: NValTest_ToPointer_001
+* @tc.desc: Test function of NVal::ToPointer interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToPointer_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToPointer_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    napi_value res = reinterpret_cast<napi_value>(0x1111);
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_external(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [succ, ret] = n_val.ToPointer();
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(ret, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToPointer_001";
+}
+
+/**
+* @tc.name: NValTest_ToBool_001
+* @tc.desc: Test function of NVal::ToBool interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToBool_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToBool_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    bool flag = true;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_bool(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(flag), testing::Return(napi_ok)));
+
+    auto [succ, res] = n_val.ToBool();
+    EXPECT_TRUE(succ);
+    EXPECT_TRUE(res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToBool_001";
+}
+
+/**
+* @tc.name: NValTest_ToBool_002
+* @tc.desc: Test function of NVal::ToBool interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToBool_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToBool_002";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    napi_valuetype valueType = napi_function;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+
+    auto [succ, res] = n_val.ToBool(true);
+    EXPECT_TRUE(succ);
+    EXPECT_TRUE(res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToBool_002";
+}
+
+/**
+* @tc.name: NValTest_ToBool_003
+* @tc.desc: Test function of NVal::ToBool interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToBool_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToBool_003";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    napi_valuetype valueType = napi_boolean;
+    bool flag = false;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+    EXPECT_CALL(GetMock(), napi_get_value_bool(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(flag), testing::Return(napi_ok)));
+
+    auto [succ, res] = n_val.ToBool(true);
+    EXPECT_TRUE(succ);
+    EXPECT_FALSE(res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToBool_003";
+}
+
+/**
+* @tc.name: NValTest_ToInt32_001
+* @tc.desc: Test function of NVal::ToInt32 interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToInt32_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToInt32_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    int32_t res = 0;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_int32(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [succ, value] = n_val.ToInt32();
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(value, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToInt32_001";
+}
+
+/**
+* @tc.name: NValTest_ToInt32_002
+* @tc.desc: Test function of NVal::ToInt32 interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToInt32_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToInt32_002";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    int32_t res = 0;
+    napi_valuetype valueType = napi_function;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+
+    auto [succ, value] = n_val.ToInt32(res);
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(value, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToInt32_002";
+}
+
+/**
+* @tc.name: NValTest_ToInt32_003
+* @tc.desc: Test function of NVal::ToInt32 interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToInt32_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToInt32_003";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    napi_valuetype valueType = napi_number;
+    int32_t res = 0;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+    EXPECT_CALL(GetMock(), napi_get_value_int32(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [succ, value] = n_val.ToInt32(res);
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(value, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToInt32_003";
+}
+
+/**
+* @tc.name: NValTest_ToInt64_001
+* @tc.desc: Test function of NVal::ToInt64 interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToInt64_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToInt64_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    int64_t res = 0;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_int64(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [succ, value] = n_val.ToInt64();
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(value, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToInt64_001";
+}
+
+/**
+* @tc.name: NValTest_ToInt64_002
+* @tc.desc: Test function of NVal::ToInt64 interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToInt64_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToInt64_002";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    int64_t res = 0;
+    napi_valuetype valueType = napi_function;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+
+    auto [succ, value] = n_val.ToInt64(res);
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(value, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToInt64_002";
+}
+
+/**
+* @tc.name: NValTest_ToInt64_003
+* @tc.desc: Test function of NVal::ToInt64 interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToInt64_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToInt64_003";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    napi_valuetype valueType = napi_number;
+    int64_t res = 0;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .Times(2)
+        .WillRepeatedly(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+    EXPECT_CALL(GetMock(), napi_get_value_int64(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [succ, value] = n_val.ToInt64(res);
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(value, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToInt64_003";
+}
+
+/**
+* @tc.name: NValTest_ToDouble_001
+* @tc.desc: Test function of NVal::ToDouble interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToDouble_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToDouble_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    double res = 0;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_double(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [succ, value] = n_val.ToDouble();
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(value, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToDouble_001";
+}
+
+/**
+* @tc.name: NValTest_ToUint32_001
+* @tc.desc: Test function of NVal::ToUint32 interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUint32_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUint32_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    uint32_t res = 0;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_uint32(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(res), testing::Return(napi_ok)));
+
+    auto [succ, value] = n_val.ToUint32();
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(value, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUint32_001";
+}
+
+/**
+* @tc.name: NValTest_ToUint64_001
+* @tc.desc: Test function of NVal::ToUint64 interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToUint64_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToUint64_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    uint32_t res = 0;
+    bool lossless = false;
+    NVal n_val = NVal(env, val);
+
+    EXPECT_CALL(GetMock(), napi_get_value_bigint_uint64(testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(
+        testing::SetArgPointee<2>(res), testing::SetArgPointee<3>(lossless), testing::Return(napi_ok)));
+
+    auto [succ, value, loss] = n_val.ToUint64();
+    EXPECT_TRUE(succ);
+    EXPECT_FALSE(loss);
+    EXPECT_EQ(value, res);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToUint64_001";
+}
+
+/**
+* @tc.name: NValTest_ToArraybuffer_001
+* @tc.desc: Test function of NVal::ToArraybuffer interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToArraybuffer_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToArraybuffer_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+
+    string str = "NValTest_ToArraybuffer_001";
+    size_t bufLen = str.length();
+    void *buffer = const_cast<char*>(str.c_str());
+
+    EXPECT_CALL(GetMock(), napi_get_arraybuffer_info(testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(
+        testing::SetArgPointee<2>(buffer), testing::SetArgPointee<3>(bufLen), testing::Return(napi_ok)));
+
+    auto [succ, buf, len] = n_val.ToArraybuffer();
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(static_cast<char*>(buf), static_cast<char*>(buffer));
+    EXPECT_EQ(len, bufLen);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToArraybuffer_001";
+}
+
+/**
+* @tc.name: NValTest_ToTypedArray_001
+* @tc.desc: Test function of NVal::ToTypedArray interface for SUCC.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_ToTypedArray_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_ToTypedArray_001";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+
+    string str = "NValTest_ToTypedArray_001";
+    size_t bufLen = str.length();
+    void *buffer = const_cast<char*>(str.c_str());
+
+    EXPECT_CALL(GetMock(), napi_get_typedarray_info(
+        testing::_, testing::_, testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(
+        testing::SetArgPointee<3>(bufLen), testing::SetArgPointee<4>(buffer), testing::Return(napi_ok)));
+
+    auto [succ, buf, len] = n_val.ToTypedArray();
+    EXPECT_TRUE(succ);
+    EXPECT_EQ(static_cast<char*>(buf), static_cast<char*>(buffer));
+    EXPECT_EQ(len, bufLen);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_ToTypedArray_001";
+}
+
+/**
+* @tc.name: NValTest_HasProp_001
+* @tc.desc: Test function of NVal::HasProp interface for null env.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_HasProp_001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_HasProp_001";
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(nullptr, val);
+    string str = "NValTest_HasProp_001";
+
+    bool result = n_val.HasProp(str);
+    EXPECT_FALSE(result);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_HasProp_001";
+}
+
+/**
+* @tc.name: NValTest_HasProp_002
+* @tc.desc: Test function of NVal::HasProp interface for null val.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_HasProp_002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_HasProp_002";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    NVal n_val = NVal(env, nullptr);
+    string str = "NValTest_HasProp_002";
+
+    bool result = n_val.HasProp(str);
+    EXPECT_FALSE(result);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_HasProp_002";
+}
+
+/**
+* @tc.name: NValTest_HasProp_003
+* @tc.desc: Test function of NVal::HasProp interface for TypeIs false.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_HasProp_003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_HasProp_003";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+    string str = "NValTest_HasProp_003";
+    napi_valuetype valueType = napi_number;
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+
+    bool result = n_val.HasProp(str);
+    EXPECT_FALSE(result);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_HasProp_003";
+}
+
+/**
+* @tc.name: NValTest_HasProp_004
+* @tc.desc: Test function of NVal::HasProp interface for FAIL.
+* @tc.size: MEDIUM
+* @tc.type: FUNC
+* @tc.level Level 1
+*/
+HWTEST_F(NValTest, NValTest_HasProp_004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "NValTest-begin NValTest_HasProp_004";
+    napi_env env = reinterpret_cast<napi_env>(0x1000);
+    napi_value val = reinterpret_cast<napi_value>(0x1234);
+    NVal n_val = NVal(env, val);
+    string str = "NValTest_HasProp_004";
+    napi_valuetype valueType = napi_object;
+    bool res = true;
+
+    EXPECT_CALL(GetMock(), napi_typeof(testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<2>(valueType), testing::Return(napi_ok)));
+    EXPECT_CALL(GetMock(), napi_has_named_property(testing::_, testing::_, testing::_, testing::_))
+        .WillOnce(testing::DoAll(testing::SetArgPointee<3>(res), testing::Return(napi_ok)));
+
+    bool result = n_val.HasProp(str);
+    EXPECT_TRUE(result);
+
+    GTEST_LOG_(INFO) << "NValTest-end NValTest_HasProp_004";
+}
+
+} // namespace Test
+} // namespace LibN
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/test/unittest/filemgmt_libn_test/src/nval_mock.cpp b/interfaces/test/unittest/filemgmt_libn_test/src/nval_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7c57b44d1060ccef15e4a7d173a7b05643ba91bd
--- /dev/null
+++ b/interfaces/test/unittest/filemgmt_libn_test/src/nval_mock.cpp
@@ -0,0 +1,207 @@
+/*
+* 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 "nval_mock.h"
+
+#include <mutex>
+
+namespace OHOS {
+namespace FileManagement {
+namespace LibN {
+namespace Test {
+
+namespace {
+std::mutex g_mockMutex;
+NValMock *g_currentMock = nullptr;
+NValMock g_defaultMock;
+} // namespace
+
+NValMock &GetNValMock()
+{
+    std::lock_guard<std::mutex> lock(g_mockMutex);
+    return g_currentMock ? *g_currentMock : g_defaultMock;
+}
+
+void SetNValMock(NValMock *mock)
+{
+    std::lock_guard<std::mutex> lock(g_mockMutex);
+    g_currentMock = mock;
+}
+
+void ResetNValMock()
+{
+    SetNValMock(nullptr);
+}
+
+} // namespace Test
+} // namespace LibN
+} // namespace FileManagement
+} // namespace OHOS
+
+#ifdef ENABLE_NAPI_MOCK
+extern "C" {
+using namespace OHOS::FileManagement::LibN::Test;
+
+napi_status napi_get_undefined(napi_env env, napi_value* result)
+{
+    return GetNValMock().napi_get_undefined(env, result);
+}
+
+napi_status napi_create_bigint_int64(napi_env env, int64_t value, napi_value* result)
+{
+    return GetNValMock().napi_create_bigint_int64(env, value, result);
+}
+
+napi_status napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result)
+{
+    return GetNValMock().napi_create_bigint_uint64(env, value, result);
+}
+
+napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result)
+{
+    return GetNValMock().napi_create_int64(env, value, result);
+}
+
+napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result)
+{
+    return GetNValMock().napi_create_int32(env, value, result);
+}
+
+napi_status napi_create_uint32(napi_env env, uint32_t value, napi_value* result)
+{
+    return GetNValMock().napi_create_uint32(env, value, result);
+}
+
+napi_status napi_create_object(napi_env env, napi_value* result)
+{
+    return GetNValMock().napi_create_object(env, result);
+}
+
+napi_status napi_get_boolean(napi_env env, bool value, napi_value* result)
+{
+    return GetNValMock().napi_get_boolean(env, value, result);
+}
+
+napi_status napi_create_string_utf8(napi_env env, const char* str, size_t length, napi_value* result)
+{
+    return GetNValMock().napi_create_string_utf8(env, str, length, result);
+}
+
+napi_status napi_create_external_arraybuffer(napi_env env, void* external_data,
+    size_t byte_length, napi_finalize finalize_cb, void* finalize_hint, napi_value* result)
+{
+    return GetNValMock().napi_create_external_arraybuffer(
+        env, external_data, byte_length, finalize_cb, finalize_hint, result);
+}
+
+napi_status napi_create_typedarray(napi_env env, napi_typedarray_type type,
+    size_t length, napi_value arraybuffer, size_t byte_offset, napi_value* result)
+{
+    return GetNValMock().napi_create_typedarray(env, type, length, arraybuffer, byte_offset, result);
+}
+
+napi_status napi_create_array(napi_env env, napi_value* result)
+{
+    return GetNValMock().napi_create_array(env, result);
+}
+
+napi_status napi_set_element(napi_env env, napi_value object, uint32_t index, napi_value value)
+{
+    return GetNValMock().napi_set_element(env, object, index, value);
+}
+
+napi_status napi_create_arraybuffer(napi_env env, size_t byte_length, void** data, napi_value* result)
+{
+    return GetNValMock().napi_create_arraybuffer(env, byte_length, data, result);
+}
+
+napi_status napi_get_value_string_utf8(napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result)
+{
+    return GetNValMock().napi_get_value_string_utf8(env, value, buf, bufsize, result);
+}
+
+napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result)
+{
+    return GetNValMock().napi_typeof(env, value, result);
+}
+
+napi_status napi_get_value_string_utf16(napi_env env, napi_value value, char16_t* buf, size_t bufsize, size_t* result)
+{
+    return GetNValMock().napi_get_value_string_utf16(env, value, buf, bufsize, result);
+}
+
+napi_status napi_is_error(napi_env env, napi_value value, bool* result)
+{
+    return GetNValMock().napi_is_error(env, value, result);
+}
+
+napi_status napi_get_value_external(napi_env env, napi_value value, void** result)
+{
+    return GetNValMock().napi_get_value_external(env, value, result);
+}
+
+napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result)
+{
+    return GetNValMock().napi_get_value_bool(env, value, result);
+}
+
+napi_status napi_get_value_int32(napi_env env, napi_value value, int32_t* result)
+{
+    return GetNValMock().napi_get_value_int32(env, value, result);
+}
+
+napi_status napi_get_value_uint32(napi_env env, napi_value value, uint32_t* result)
+{
+    return GetNValMock().napi_get_value_uint32(env, value, result);
+}
+
+napi_status napi_get_value_int64(napi_env env, napi_value value, int64_t* result)
+{
+    return GetNValMock().napi_get_value_int64(env, value, result);
+}
+
+napi_status napi_get_value_double(napi_env env, napi_value value, double* result)
+{
+    return GetNValMock().napi_get_value_double(env, value, result);
+}
+
+napi_status napi_get_value_bigint_uint64(napi_env env, napi_value value, uint64_t* result, bool* lossless)
+{
+    return GetNValMock().napi_get_value_bigint_uint64(env, value, result, lossless);
+}
+
+napi_status napi_get_array_length(napi_env env, napi_value value, uint32_t* result)
+{
+    return GetNValMock().napi_get_array_length(env, value, result);
+}
+
+napi_status napi_get_arraybuffer_info(napi_env env, napi_value arraybuffer, void** data, size_t* byte_length)
+{
+    return GetNValMock().napi_get_arraybuffer_info(env, arraybuffer, data, byte_length);
+}
+
+napi_status napi_get_typedarray_info(napi_env env,  napi_value typedarray,
+    napi_typedarray_type* type, size_t* length, void** data, napi_value* arraybuffer, size_t* byte_offset)
+{
+    return GetNValMock().napi_get_typedarray_info(env, typedarray, type, length, data, arraybuffer, byte_offset);
+}
+
+napi_status napi_has_named_property(napi_env env, napi_value object, const char* utf8name, bool* result)
+{
+    return GetNValMock().napi_has_named_property(env, object, utf8name, result);
+}
+
+} // extern "C"
+#endif
\ No newline at end of file