diff --git a/frameworks/native/backup_ext/src/ext_backup_js.cpp b/frameworks/native/backup_ext/src/ext_backup_js.cpp
index 9b9fbcb52cb22bf49d249a713d305ed75fd5321c..8fb1e6c8e02e1daa76959482c47066126a2554a9 100644
--- a/frameworks/native/backup_ext/src/ext_backup_js.cpp
+++ b/frameworks/native/backup_ext/src/ext_backup_js.cpp
@@ -867,34 +867,19 @@ int ExtBackupJs::CallJsMethod(const std::string &funcName,
                               InputArgsParser argParser,
                               ResultValueParser retParser)
 {
-    uv_loop_s *loop = nullptr;
-    napi_status status = napi_get_uv_event_loop(jsRuntime.GetNapiEnv(), &loop);
-    if (status != napi_ok) {
-        HILOGE("failed to get uv event loop.");
-        return EINVAL;
-    }
     auto param = std::make_shared<CallJsParam>(funcName, &jsRuntime, jsObj, argParser, retParser);
     BExcepUltils::BAssert(param, BError::Codes::EXT_BROKEN_FRAMEWORK, "failed to new param.");
 
-    auto work = std::make_shared<uv_work_t>();
-    BExcepUltils::BAssert(work, BError::Codes::EXT_BROKEN_FRAMEWORK, "failed to new uv_work_t.");
-
-    work->data = reinterpret_cast<void *>(param.get());
     HILOGI("Will execute current js method");
-    auto task = [work {work.get()}]() {
-        if (work == nullptr) {
-            HILOGE("failed to get work.");
-            return;
-        }
-        HILOGI("AsyncWork Enter, %{public}zu", (size_t)work);
-        CallJsParam *param = reinterpret_cast<CallJsParam *>(work->data);
+    auto task = [param {param}]() {
+        HILOGI("AsyncWork Enter, %{public}zu", (size_t)param.get());
         do {
             if (param == nullptr) {
                 HILOGE("failed to get CallJsParam.");
                 break;
             }
             HILOGI("Start call current js method");
-            if (DoCallJsMethod(param) != ERR_OK) {
+            if (DoCallJsMethod(param.get()) != ERR_OK) {
                 HILOGE("failed to call DoCallJsMethod.");
             }
         } while (false);
@@ -903,9 +888,11 @@ int ExtBackupJs::CallJsMethod(const std::string &funcName,
         param->isReady.store(true);
         param->backupOperateCondition.notify_all();
     };
-    auto ret = napi_send_event(jsRuntime.GetNapiEnv(), task, napi_eprio_high);
+    uint64_t handleId = 0;
+    auto ret = napi_send_cancelable_event(jsRuntime.GetNapiEnv(), task, nullptr, napi_eprio_high, &handleId, funcName);
     if (ret != napi_status::napi_ok) {
-        HILOGE("failed to napi_send_event, ret:%{public}d.", ret);
+        HILOGE("failed to napi_send_cancelable_event, ret:%{public}d, handleId:%{public}d, name:%{public}s.",
+            ret, handleId, funcName);
         return EINVAL;
     }
     HILOGI("Wait execute current js method");
diff --git a/interfaces/kits/js/backup/general_callbacks.cpp b/interfaces/kits/js/backup/general_callbacks.cpp
index acf3bd5dd6d07264ebd9f744f97e722af7863b9b..3602d26e782bb5e918f32da8c348aded0d30fcb5 100644
--- a/interfaces/kits/js/backup/general_callbacks.cpp
+++ b/interfaces/kits/js/backup/general_callbacks.cpp
@@ -62,38 +62,28 @@ BackupRestoreCallback::~BackupRestoreCallback()
     }
 
     unique_ptr<LibN::NAsyncContextCallback> ptr(ctx_);
-    uv_loop_s *loop = nullptr;
-    napi_status status = napi_get_uv_event_loop(env_, &loop);
-    if (status != napi_ok) {
-        HILOGE("Failed to get uv event loop");
-        ptr->cb_.CleanJsEnv();
-        return;
-    }
-
-    auto work = make_unique<uv_work_t>();
-    if (work == nullptr) {
-        HILOGE("Failed to new uv_work_t");
-        return;
-    }
-    work->data = static_cast<void *>(ctx_);
-
-    auto task = [work {work.get()}]() {
-        if (work == nullptr) {
-            HILOGE("failed to get work.");
+    auto task = [ctx {ptr.get()}]() {
+        if (ctx == nullptr) {
+            HILOGE("failed to get ctx.");
             return;
         }
-        LibN::NAsyncContextCallback *ctx = static_cast<LibN::NAsyncContextCallback *>(work->data);
         HILOGI("BackupRestoreCallback destruct delete ctx");
+        if (bool(ctx->cb_)) {
+            ctx->cb_.CleanJsEnv();
+        }
         delete ctx;
-        delete work;
     };
-    auto ret = napi_send_event(env_, task, napi_eprio_high);
+    uint64_t handleId = 0;
+    auto ret = napi_send_cancelable_event(env_, task, nullptr, napi_eprio_high, &handleId, "destructor");
     if (ret != napi_status::napi_ok) {
-        HILOGE("Failed to call napi_send_event, ret:%{public}d, status:%{public}d", ret, status);
+        HILOGE("failed to napi_send_cancelable_event, ret:%{public}d, handleId:%{public}d, name:%{public}s.",
+            ret, handleId, "destructor");
+        if (bool(ctx_->cb_)) {
+            ctx_->cb_.CleanJsEnv();
+        }
         return;
     }
     ptr.release();
-    work.release();
     ctx_ = nullptr;
     HILOGI("BackupRestoreCallback destruct end");
 }
@@ -128,12 +118,12 @@ static void DoCallJsMethod(napi_env env, void *data, InputArgsParser argParser)
     }
     napi_value global = nullptr;
     napi_get_global(env, &global);
-    napi_value callback = ctx->cb_.Deref(env).val_;
     if (!bool(ctx->cb_)) {
         HILOGE("Failed to get ref.");
         napi_close_handle_scope(env, scope);
         return;
     }
+    napi_value callback = ctx->cb_.Deref(env).val_;
     napi_value result = nullptr;
     napi_status status = napi_call_function(env, global, callback, argv.size(), argv.data(), &result);
     if (status != napi_ok) {
@@ -146,29 +136,16 @@ static void DoCallJsMethod(napi_env env, void *data, InputArgsParser argParser)
 void BackupRestoreCallback::CallJsMethod(InputArgsParser argParser)
 {
     HILOGI("call BackupRestoreCallback CallJsMethod begin.");
-    uv_loop_s *loop = nullptr;
-    napi_status status = napi_get_uv_event_loop(env_, &loop);
-    if (status != napi_ok) {
-        HILOGE("failed to get uv event loop.");
-        return;
-    }
     auto workArgs = make_shared<WorkArgs>();
-    auto work = make_unique<uv_work_t>();
-    if (workArgs == nullptr || work == nullptr) {
+    if (workArgs == nullptr) {
         HILOGE("failed to new workArgs or uv_work_t.");
         return;
     }
     workArgs->ptr = this;
     workArgs->argParser = argParser;
-    work->data = reinterpret_cast<void *>(workArgs.get());
     HILOGI("Will execute current js method");
-    auto task = [work {work.get()}]() {
-        if (work == nullptr) {
-            HILOGE("failed to get work.");
-            return;
-        }
-        HILOGI("AsyncWork Enter, %{public}zu", (size_t)work);
-        auto workArgs = reinterpret_cast<WorkArgs *>(work->data);
+    auto task = [workArgs {workArgs}]() {
+        HILOGI("AsyncWork Enter, %{public}zu", (size_t)workArgs.get());
         do {
             if (workArgs == nullptr) {
                 HILOGE("failed to get workArgs.");
@@ -180,18 +157,17 @@ void BackupRestoreCallback::CallJsMethod(InputArgsParser argParser)
         std::unique_lock<std::mutex> lock(workArgs->callbackMutex);
         workArgs->isReady.store(true);
         workArgs->callbackCondition.notify_all();
-        delete work;
     };
-    auto ret = napi_send_event(env_, task, napi_eprio_high);
+    uint64_t handleId = 0;
+    auto ret = napi_send_cancelable_event(env_, task, nullptr, napi_eprio_high, &handleId, "jsmethod");
     if (ret != napi_status::napi_ok) {
-        HILOGE("failed to napi_send_event, ret:%{public}d.", ret);
-        work.reset();
-        return;
+        HILOGE("failed to napi_send_cancelable_event, ret:%{public}d, handleId:%{public}d, name:%{public}s.",
+            ret, handleId, "jsmethod");
+        return EINVAL;
     }
     std::unique_lock<std::mutex> lock(workArgs->callbackMutex);
     HILOGI("Wait execute callback method end");
     workArgs->callbackCondition.wait(lock, [workArgs]() { return workArgs->isReady.load(); });
-    work.release();
     HILOGI("call BackupRestoreCallback CallJsMethod end.");
 }
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/mock/napi/include/napi_mock.h b/tests/mock/napi/include/napi_mock.h
index 796d02ca514be6da94fd7acc3812a732d496ff1e..73a594592fe065d47f66693b1806c17769924282 100644
--- a/tests/mock/napi/include/napi_mock.h
+++ b/tests/mock/napi/include/napi_mock.h
@@ -31,12 +31,12 @@ class Napi {
 public:
     virtual ~Napi() = default;
 public:
-    virtual napi_status napi_get_uv_event_loop(napi_env, struct uv_loop_s**) = 0;
     virtual napi_status napi_call_function(napi_env, napi_value, napi_value, size_t, const napi_value*, napi_value*)
         = 0;
     virtual napi_status napi_get_reference_value(napi_env, napi_ref, napi_value*) = 0;
     virtual napi_status napi_get_named_property(napi_env, napi_value, const char*, napi_value*) = 0;
-    virtual napi_status napi_send_event(napi_env, const std::function<void()>, napi_event_priority) = 0;
+    virtual napi_status napi_send_cancelable_event(napi_env, const std::function<void(void*)>, void*,
+        napi_event_priority, uint64_t*, const char*) = 0;
     virtual napi_status napi_get_value_int32(napi_env, napi_value, int32_t*) = 0;
     virtual napi_status napi_get_value_int64(napi_env, napi_value, int64_t*) = 0;
     virtual napi_status napi_create_string_utf8(napi_env, const char*, size_t, napi_value*) = 0;
@@ -67,12 +67,12 @@ public:
 
 class NapiMock : public Napi {
 public:
-    MOCK_METHOD2(napi_get_uv_event_loop, napi_status(napi_env, struct uv_loop_s**));
     MOCK_METHOD6(napi_call_function, napi_status(napi_env, napi_value, napi_value, size_t, const napi_value*,
         napi_value*));
     MOCK_METHOD3(napi_get_reference_value, napi_status(napi_env, napi_ref, napi_value*));
     MOCK_METHOD4(napi_get_named_property, napi_status(napi_env, napi_value, const char*, napi_value*));
-    MOCK_METHOD3(napi_send_event, napi_status(napi_env, const std::function<void()>, napi_event_priority));
+    MOCK_METHOD3(napi_send_cancelable_event, napi_status(napi_env, (const std::function<void(void*)>), void*,
+        napi_event_priority, uint64_t*, const char*));
     MOCK_METHOD3(napi_get_value_int32, napi_status(napi_env, napi_value, int32_t*));
     MOCK_METHOD3(napi_get_value_int64, napi_status(napi_env, napi_value, int64_t*));
     MOCK_METHOD3(napi_create_int64, napi_status(napi_env, int64_t, napi_value*));
diff --git a/tests/mock/napi/src/napi_mock.cpp b/tests/mock/napi/src/napi_mock.cpp
index f7390ad98f55e41ccd493f0ed48c12cf76e34531..a42b66251e9b6e7d3f520958be26104daa565f26 100644
--- a/tests/mock/napi/src/napi_mock.cpp
+++ b/tests/mock/napi/src/napi_mock.cpp
@@ -16,14 +16,11 @@
 #include "napi_mock.h"
 #include "uv.h"
 
-napi_status napi_send_event(napi_env env, const std::function<void()> cb, napi_event_priority priority)
+napi_status napi_send_cancelable_event(napi_env env, const std::function<void(void*)> cb, void* data,
+    napi_event_priority priority, uint64_t* handleId, const char* name)
 {
-    return OHOS::FileManagement::Backup::Napi::napi->napi_send_event(env, cb, priority);
-}
-
-napi_status napi_get_uv_event_loop(napi_env env, struct uv_loop_s** loop)
-{
-    return OHOS::FileManagement::Backup::Napi::napi->napi_get_uv_event_loop(env, loop);
+    return OHOS::FileManagement::Backup::Napi::napi->napi_send_cancelable_event(env, cb, data, priority, handleId,
+        name);
 }
 
 napi_status napi_call_function(napi_env env, napi_value recv, napi_value func, size_t argc, const napi_value* argv,
diff --git a/tests/unittests/backup_ext/ext_backup_js_test.cpp b/tests/unittests/backup_ext/ext_backup_js_test.cpp
index 36b95fb9023be6cac99eae11c8adfe45a5e0c0e2..4e9febb621d9bd01ed9a2385e423d3306fc1f87a 100644
--- a/tests/unittests/backup_ext/ext_backup_js_test.cpp
+++ b/tests/unittests/backup_ext/ext_backup_js_test.cpp
@@ -816,16 +816,9 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsMethod_0100, testing::ext::Tes
 {
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_CallJsMethod_0100";
     try {
-        extBackupJs->jsObj_ = make_unique<NativeReferenceMock>();
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->CallJsMethod("", *jsRuntime, extBackupJs->jsObj_.get(), nullptr, nullptr);
-        EXPECT_EQ(ret, EINVAL);
-
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
-        ret = extBackupJs->CallJsMethod("", *jsRuntime, extBackupJs->jsObj_.get(), nullptr, nullptr);
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
+        auto ret = extBackupJs->CallJsMethod("", *jsRuntime, extBackupJs->jsObj_.get(), nullptr, nullptr);
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -1059,26 +1052,19 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsOnBackupEx_0100, testing::ext:
 {
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_CallJsOnBackupEx_0100";
     try {
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->CallJsOnBackupEx();
-        EXPECT_EQ(ret, EINVAL);
-
         extBackupJs->callbackInfoEx_ = std::make_shared<CallbackInfoEx>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_value_string_utf8(_, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
-        ret = extBackupJs->CallJsOnBackupEx();
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
+        auto ret = extBackupJs->CallJsOnBackupEx();
         EXPECT_EQ(ret, EINVAL);
 
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_FIRST>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_get_and_clear_last_exception(_, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJsOnBackupEx();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1103,13 +1089,12 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsOnBackupEx_0200, testing::ext:
     try {
         extBackupJs->callbackInfoEx_ = std::make_shared<CallbackInfoEx>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_promise(_, _, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_SECOND>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_open_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_close_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_named_property(_, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         auto ret = extBackupJs->CallJsOnBackupEx();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1132,25 +1117,18 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsOnBackup_0100, testing::ext::T
 {
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_CallJsOnBackup_0100";
     try {
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->CallJsOnBackup();
-        EXPECT_EQ(ret, EINVAL);
-
         extBackupJs->callbackInfo_ = std::make_shared<CallbackInfo>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
-        ret = extBackupJs->CallJsOnBackup();
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
+        auto ret = extBackupJs->CallJsOnBackup();
         EXPECT_EQ(ret, EINVAL);
 
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_FIRST>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_get_and_clear_last_exception(_, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJsOnBackup();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1175,13 +1153,12 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsOnBackup_0200, testing::ext::T
     try {
         extBackupJs->callbackInfo_ = std::make_shared<CallbackInfo>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_promise(_, _, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_SECOND>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_open_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_close_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_named_property(_, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         auto ret = extBackupJs->CallJsOnBackup();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1204,26 +1181,19 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJSRestoreEx_0100, testing::ext::
 {
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_CallJSRestoreEx_0100";
     try {
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->CallJSRestoreEx();
-        EXPECT_EQ(ret, EINVAL);
-
         extBackupJs->callbackInfoEx_ = std::make_shared<CallbackInfoEx>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_value_string_utf8(_, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
-        ret = extBackupJs->CallJSRestoreEx();
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
+        auto ret = extBackupJs->CallJSRestoreEx();
         EXPECT_EQ(ret, EINVAL);
 
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_FIRST>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_get_and_clear_last_exception(_, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJSRestoreEx();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1248,13 +1218,12 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJSRestoreEx_0200, testing::ext::
     try {
         extBackupJs->callbackInfoEx_ = std::make_shared<CallbackInfoEx>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_promise(_, _, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_SECOND>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_open_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_close_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_named_property(_, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         auto ret = extBackupJs->CallJSRestoreEx();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1277,25 +1246,18 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJSRestore_0100, testing::ext::Te
 {
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_CallJSRestore_0100";
     try {
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->CallJSRestore();
-        EXPECT_EQ(ret, EINVAL);
-
         extBackupJs->callbackInfo_ = std::make_shared<CallbackInfo>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
-        ret = extBackupJs->CallJSRestore();
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
+        auto ret = extBackupJs->CallJSRestore();
         EXPECT_EQ(ret, EINVAL);
 
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_FIRST>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_get_and_clear_last_exception(_, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJSRestore();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1320,13 +1282,12 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJSRestore_0200, testing::ext::Te
     try {
         extBackupJs->callbackInfo_ = std::make_shared<CallbackInfo>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_promise(_, _, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_SECOND>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_open_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_close_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_named_property(_, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         auto ret = extBackupJs->CallJSRestore();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1350,17 +1311,11 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_GetBackupInfo_0100, testing::ext::Te
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_GetBackupInfo_0100";
     try {
         extBackupJs->jsObj_ = make_unique<NativeReferenceMock>();
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->GetBackupInfo([](ErrCode, std::string){});
-        EXPECT_EQ(ret, EINVAL);
-
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_value_string_utf8(_, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
-        ret = extBackupJs->GetBackupInfo([](ErrCode, std::string){});
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
+        auto ret = extBackupJs->GetBackupInfo([](ErrCode, std::string){});
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -1385,21 +1340,19 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_GetBackupInfo_0200, testing::ext::Te
         extBackupJs->jsObj_ = make_unique<NativeReferenceMock>();
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_value_string_utf8(_, _, _, _, _)).WillOnce(Return(napi_ok))
             .WillOnce(Return(napi_ok));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         auto ret = extBackupJs->GetBackupInfo([](ErrCode, std::string){});
         EXPECT_EQ(ret, EINVAL);
 
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_promise(_, _, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_SECOND>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_open_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_close_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_named_property(_, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->GetBackupInfo([](ErrCode, std::string){});
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1422,18 +1375,11 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_OnProcess_0100, testing::ext::TestSi
 {
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_OnProcess_0100";
     try {
-        extBackupJs->jsObj_ = make_unique<NativeReferenceMock>();
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->OnProcess([](ErrCode, std::string){});
-        EXPECT_EQ(ret, EINVAL);
-
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_value_string_utf8(_, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
-        ret = extBackupJs->OnProcess([](ErrCode, std::string){});
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
+        auto ret = extBackupJs->OnProcess([](ErrCode, std::string){});
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
         EXPECT_TRUE(false);
@@ -1456,18 +1402,16 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_OnProcess_0200, testing::ext::TestSi
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_OnProcess_0200";
     try {
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_value_string_utf8(_, _, _, _, _)).WillOnce(Return(napi_ok))
         .WillOnce(Return(napi_ok));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         auto ret = extBackupJs->OnProcess([](ErrCode, std::string){});
         EXPECT_EQ(ret, EINVAL);
 
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->OnProcess([](ErrCode, std::string){});
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
diff --git a/tests/unittests/backup_ext/external_ext_backup_js_test.cpp b/tests/unittests/backup_ext/external_ext_backup_js_test.cpp
index 0350c33cddbbbe87124086ec9533cbf6bd0c1991..6969897d3516850f4663012addcd48ea45a81fae 100644
--- a/tests/unittests/backup_ext/external_ext_backup_js_test.cpp
+++ b/tests/unittests/backup_ext/external_ext_backup_js_test.cpp
@@ -817,14 +817,8 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsMethod_0100, testing::ext::Tes
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_CallJsMethod_0100";
     try {
         extBackupJs->jsObj_ = make_unique<NativeReferenceMock>();
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->CallJsMethod("", *jsRuntime, extBackupJs->jsObj_.get(), nullptr, nullptr);
-        EXPECT_EQ(ret, EINVAL);
-
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJsMethod("", *jsRuntime, extBackupJs->jsObj_.get(), nullptr, nullptr);
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
diff --git a/tests/unittests/backup_ext/tests/unittests/backup_ext/ext_backup_js_external_test.cpp b/tests/unittests/backup_ext/tests/unittests/backup_ext/ext_backup_js_external_test.cpp
index 75c5dafadb04d01cf4badbaaf5a58830f63796a7..61e2d806be7f9a1cefbc4f863fb7997b2ce00271 100644
--- a/tests/unittests/backup_ext/tests/unittests/backup_ext/ext_backup_js_external_test.cpp
+++ b/tests/unittests/backup_ext/tests/unittests/backup_ext/ext_backup_js_external_test.cpp
@@ -817,14 +817,8 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsMethod_0100, testing::ext::Tes
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_CallJsMethod_0100";
     try {
         extBackupJs->jsObj_ = make_unique<NativeReferenceMock>();
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->CallJsMethod("", *jsRuntime, extBackupJs->jsObj_.get(), nullptr, nullptr);
-        EXPECT_EQ(ret, EINVAL);
-
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJsMethod("", *jsRuntime, extBackupJs->jsObj_.get(), nullptr, nullptr);
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1059,26 +1053,19 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsOnBackupEx_0100, testing::ext:
 {
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_CallJsOnBackupEx_0100";
     try {
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->CallJsOnBackupEx();
-        EXPECT_EQ(ret, EINVAL);
-
         extBackupJs->callbackInfoEx_ = std::make_shared<CallbackInfoEx>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_value_string_utf8(_, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJsOnBackupEx();
         EXPECT_EQ(ret, EINVAL);
 
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_FIRST>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_get_and_clear_last_exception(_, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJsOnBackupEx();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1103,13 +1090,12 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsOnBackupEx_0200, testing::ext:
     try {
         extBackupJs->callbackInfoEx_ = std::make_shared<CallbackInfoEx>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_promise(_, _, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_SECOND>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_open_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_close_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_named_property(_, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         auto ret = extBackupJs->CallJsOnBackupEx();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1132,25 +1118,18 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsOnBackup_0100, testing::ext::T
 {
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_CallJsOnBackup_0100";
     try {
-        EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg));
-        auto ret = extBackupJs->CallJsOnBackup();
-        EXPECT_EQ(ret, EINVAL);
-
         extBackupJs->callbackInfo_ = std::make_shared<CallbackInfo>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJsOnBackup();
         EXPECT_EQ(ret, EINVAL);
 
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_FIRST>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_get_and_clear_last_exception(_, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         ret = extBackupJs->CallJsOnBackup();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {
@@ -1175,13 +1154,12 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_CallJsOnBackup_0200, testing::ext::T
     try {
         extBackupJs->callbackInfo_ = std::make_shared<CallbackInfo>([](ErrCode, std::string){});
         EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
-        EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_is_promise(_, _, _))
             .WillOnce(DoAll(SetArgPointee<ARG_INDEX_SECOND>(true), Return(napi_ok)));
         EXPECT_CALL(*napiMock, napi_open_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_close_handle_scope(_, _)).WillOnce(Return(napi_ok));
         EXPECT_CALL(*napiMock, napi_get_named_property(_, _, _, _)).WillOnce(Return(napi_invalid_arg));
-        EXPECT_CALL(*napiMock, napi_send_event(_, _, _)).WillOnce(Return(napi_invalid_arg));
+        EXPECT_CALL(*napiMock, napi_send_cancelable_event(_, _, _, _, _, _)).WillOnce(Return(napi_invalid_arg));
         auto ret = extBackupJs->CallJsOnBackup();
         EXPECT_EQ(ret, EINVAL);
     } catch (...) {