diff --git a/interfaces/inner_api/file_access/src/file_access_helper.cpp b/interfaces/inner_api/file_access/src/file_access_helper.cpp
index 73ab30c63ca90eb1643f82167efb2175d5fb9d0d..58aa7a9e016df30181ab504faff6ffd78591674e 100644
--- a/interfaces/inner_api/file_access/src/file_access_helper.cpp
+++ b/interfaces/inner_api/file_access/src/file_access_helper.cpp
@@ -57,16 +57,14 @@ bool FileAccessHelper::IsFilePathValid(const std::string &filePath)
     size_t pos = filePath.find(PATH_INVALID_FLAG1);
     while (pos != string::npos) {
         if (pos == 0 || filePath[pos - 1] == FILE_SEPARATOR_CHAR) {
-            HILOG_ERROR("Relative path is not allowed, path contain ../, path = %{private}s",
-                filePath.c_str());
+            HILOG_ERROR("Relative path is not allowed, path contain ../");
             return false;
         }
         pos = filePath.find(PATH_INVALID_FLAG1, pos + PATH_INVALID_FLAG_LEN);
     }
     pos = filePath.rfind(PATH_INVALID_FLAG2);
     if ((pos != string::npos) && (filePath.size() - pos == PATH_INVALID_FLAG_LEN)) {
-        HILOG_ERROR("Relative path is not allowed, path tail is /.., path = %{private}s",
-            filePath.c_str());
+        HILOG_ERROR("Relative path is not allowed, path tail is /..");
         return false;
     }
     return true;
diff --git a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp
index 83a876aed9003ddfa43d8e35a75e6891252ab600..1e709a22889c807883cfcb06fb748bde3a20fd18 100644
--- a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp
+++ b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp
@@ -79,15 +79,15 @@ void JsFileAccessExtAbility::Init(const std::shared_ptr<AbilityLocalRecord> &rec
     trace.Start("Init");
     FileAccessExtAbility::Init(record, application, handler, token);
     std::string srcPath = "";
+    if (abilityInfo_ == nullptr) {
+        HILOG_ERROR("abilityInfo_ is nullptr");
+        return;
+    }
     GetSrcPath(srcPath);
     if (srcPath.empty()) {
         HILOG_ERROR("Failed to get srcPath");
         return;
     }
-    if (abilityInfo_ == nullptr) {
-        HILOG_ERROR("abilityInfo_ is nullptr");
-        return;
-    }
     std::string moduleName(Extension::abilityInfo_->moduleName);
     moduleName.append("::").append(abilityInfo_->name);
     HandleScope handleScope(jsRuntime_);
diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn
index 618ca1d9ca090e2891f510fc91a8c456007a8954..1e41b55e2c30d77fc064eeebcd3c9fd1383d1bff 100644
--- a/test/unittest/BUILD.gn
+++ b/test/unittest/BUILD.gn
@@ -14,53 +14,6 @@
 import("//build/test.gni")
 import("//foundation/filemanagement/user_file_service/filemanagement_aafwk.gni")
 
-ohos_unittest("medialibrary_file_access_test") {
-  branch_protector_ret = "pac_ret"
-  sanitize = {
-    integer_overflow = true
-    cfi = true
-    cfi_cross_dso = true
-    debug = false
-  }
-  module_out_path = "user_file_service/user_file_service"
-
-  sources = [
-    "medialibrary_file_access_test_basic.cpp",
-    "medialibrary_file_access_test_info.cpp",
-  ]
-
-  include_dirs =
-      [ "${user_file_service_path}/interfaces/inner_api/file_access/include" ]
-
-  configs = [ "//build/config/compiler:exceptions" ]
-
-  deps = [ "${user_file_service_path}/interfaces/inner_api/file_access:file_access_extension_ability_kit" ]
-
-  external_deps = [
-    "ability_base:want",
-    "ability_base:zuri",
-    "ability_runtime:ability_context_native",
-    "ability_runtime:ability_manager",
-    "ability_runtime:abilitykit_native",
-    "ability_runtime:app_context",
-    "ability_runtime:app_manager",
-    "ability_runtime:runtime",
-    "ability_runtime:wantagent_innerkits",
-    "access_token:libaccesstoken_sdk",
-    "access_token:libnativetoken",
-    "access_token:libtoken_setproc",
-    "c_utils:utils",
-    "googletest:gmock_main",
-    "googletest:gtest_main",
-    "ipc:ipc_core",
-    "ipc:rpc",
-    "samgr:samgr_proxy",
-  ]
-
-  resource_config_file =
-      "${user_file_service_path}/test/unittest/resources/ohos_test.xml"
-}
-
 ohos_unittest("external_file_access_basic_test") {
   branch_protector_ret = "pac_ret"
   sanitize = {
diff --git a/test/unittest/mock/js_native_api_mock.cpp b/test/unittest/mock/js_native_api_mock.cpp
index 2e27a6edcf8c7c59e1148f039aeda423cfe606f2..889e7a6271cc50b8507bd1acbf65fb863f3f4d6d 100644
--- a/test/unittest/mock/js_native_api_mock.cpp
+++ b/test/unittest/mock/js_native_api_mock.cpp
@@ -18,124 +18,196 @@
 
 napi_status napi_get_uv_event_loop(napi_env env, struct uv_loop_s** loop)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_uv_event_loop(env, loop);
 }
 
 napi_status napi_call_function(napi_env env, napi_value recv, napi_value func, size_t argc, const napi_value* argv,
     napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_call_function(env, recv, func, argc, argv, result);
 }
 
 napi_status napi_get_reference_value(napi_env env, napi_ref ref, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_reference_value(env, ref, result);
 }
 
 napi_status napi_get_named_property(napi_env env, napi_value object, const char* utf8name, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_named_property(env, object, utf8name, result);
 }
 
 napi_status napi_get_value_int32(napi_env env, napi_value value, int32_t* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_value_int32(env, value, result);
 }
 
 napi_status napi_get_value_int64(napi_env env, napi_value value, int64_t* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_value_int64(env, value, result);
 }
 
 napi_status napi_create_string_utf8(napi_env env, const char* str, size_t length, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_create_string_utf8(env, str, length, result);
 }
 
 napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_create_int32(env, value, result);
 }
 
 napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_create_int64(env, value, result);
 }
 
 napi_status napi_get_value_string_utf8(napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_value_string_utf8(env, value, buf, bufsize, result);
 }
 
 napi_status napi_get_boolean(napi_env env, bool value, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_boolean(env, value, result);
 }
 
 napi_status napi_create_array(napi_env env, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_create_array(env, result);
 }
 
 napi_status napi_get_array_length(napi_env env, napi_value value, uint32_t* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_array_length(env, value, result);
 }
 
 napi_status napi_get_element(napi_env env, napi_value object, uint32_t index, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_element(env, object, index, result);
 }
 
 napi_status napi_escape_handle(napi_env env, napi_escapable_handle_scope scope, napi_value escapee, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_escape_handle(env, scope, escapee, result);
 }
 
 napi_status napi_get_null(napi_env env, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_null(env, result);
 }
 
 napi_status napi_create_object(napi_env env, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_create_object(env, result);
 }
 
 napi_status napi_create_array_with_length(napi_env env, size_t length, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_create_array_with_length(env, length, result);
 }
 
 napi_status napi_create_double(napi_env env, double value, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_create_double(env, value, result);
 }
 
 napi_status napi_set_named_property(napi_env env, napi_value object, const char* utf8Name, napi_value value)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_set_named_property(env, object, utf8Name, value);
 }
 
 napi_status napi_create_function(napi_env env, const char* utf8name, size_t length, napi_callback cb, void* data,
     napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_create_function(env, utf8name, length, cb, data, result);
 }
 
 napi_status napi_get_cb_info(napi_env env, napi_callback_info cbinfo, size_t* argc, napi_value* argv,
     napi_value* thisArg, void** data)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_cb_info(env, cbinfo, argc, argv, thisArg, data);
 }
 
 napi_status napi_get_undefined(napi_env env, napi_value* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_undefined(env, result);
 }
 
 napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result)
 {
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_get_value_bool(env, value, result);
 }
 
@@ -145,5 +217,8 @@ napi_status napi_send_event(napi_env env, const std::function<void()>& cb, napi_
     if (cb) {
         cb();
     }
+    if (OHOS::FileAccessFwk::Assistant::ins_ == nullptr) {
+        return napi_invalid_arg;
+    }
     return OHOS::FileAccessFwk::Assistant::ins_->napi_send_event(env, cb, priority);
 }
\ No newline at end of file
diff --git a/test/unittest/mock/message_parcel_mock.cpp b/test/unittest/mock/message_parcel_mock.cpp
index 3036a04fb29f197d308fca0a36f7ad5da0432a22..b1f73d73c9d1abc9e5af496125de99e312e5e1fc 100644
--- a/test/unittest/mock/message_parcel_mock.cpp
+++ b/test/unittest/mock/message_parcel_mock.cpp
@@ -29,91 +29,145 @@ Parcelable::Parcelable(bool asRemote)
 
 bool MessageParcel::WriteInterfaceToken(std::u16string name)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->WriteInterfaceToken(name);
 }
 
 std::u16string MessageParcel::ReadInterfaceToken()
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return {};
+    }
     return UMessageParcel::messageParcel->ReadInterfaceToken();
 }
 
 bool Parcel::WriteParcelable(const Parcelable *object)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->WriteParcelable(object);
 }
 
 bool Parcel::WriteInt32(int32_t value)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->WriteInt32(value);
 }
 
 int32_t Parcel::ReadInt32()
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return -1;
+    }
     return UMessageParcel::messageParcel->ReadInt32();
 }
 
 bool Parcel::ReadInt32(int32_t &value)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->ReadInt32(value);
 }
 
 bool Parcel::WriteRemoteObject(const Parcelable *object)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->WriteRemoteObject(object);
 }
 
 bool MessageParcel::WriteRemoteObject(const sptr<IRemoteObject> &object)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->WriteRemoteObject(object);
 }
 
 sptr<IRemoteObject> MessageParcel::ReadRemoteObject()
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return nullptr;
+    }
     return UMessageParcel::messageParcel->ReadRemoteObject();
 }
 
 bool Parcel::ReadBool()
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->ReadBool();
 }
 
 bool Parcel::ReadBool(bool &value)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->ReadBool(value);
 }
 
 bool Parcel::WriteBool(bool value)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->WriteBool(value);
 }
 
 bool Parcel::WriteString(const std::string &value)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->WriteString(value);
 }
 
 bool Parcel::ReadString(std::string &value)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->ReadString(value);
 }
 
 bool Parcel::ReadStringVector(std::vector<std::string> *value)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->ReadStringVector(value);
 }
 
 bool MessageParcel::WriteFileDescriptor(int fd)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->WriteFileDescriptor(fd);
 }
 
 int MessageParcel::ReadFileDescriptor()
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return -1;
+    }
     return UMessageParcel::messageParcel->ReadFileDescriptor();
 }
 
 bool Parcel::ReadUint32(uint32_t &value)
 {
+    if (UMessageParcel::messageParcel == nullptr) {
+        return false;
+    }
     return UMessageParcel::messageParcel->ReadUint32(value);
 }
 } // namespace OHOS
\ No newline at end of file
diff --git a/test/unittest/mock/service_registry_mock.cpp b/test/unittest/mock/service_registry_mock.cpp
index 00c82437b76708560e8fd9af8d1f3926e2c7bdeb..f666ffb35c3bd39d76e5f99ea612c23579211c75 100644
--- a/test/unittest/mock/service_registry_mock.cpp
+++ b/test/unittest/mock/service_registry_mock.cpp
@@ -31,6 +31,9 @@ SystemAbilityManagerClient& SystemAbilityManagerClient::GetInstance()
 
 sptr<ISystemAbilityManager> SystemAbilityManagerClient::GetSystemAbilityManager()
 {
+    if (Assistant::ins_ == nullptr) {
+        return false;
+    }
     if (Assistant::ins_->Bool() == false) {
         return nullptr;
     }