!18220 merge TDD1 into master

test ai tdd

Created-by: RuiChen_01
Commit-by: RuiChen_01
Merged-by: openharmony_ci
Description: **IssueNo**:

**Description**:

**稳定性自检：**
| 自检项                                                       | 自检结果  |
| ------------------------------------------------------------ | -------- |
| 涉及跨进程调用的相关操作需要抛至主线程或加锁防止并发              |          |
| 成员变量进行赋值或创建需要排查并发                               |          |
| 谨慎在lambda表达式中使用引用捕获                                |          |
| 谨慎在未经拷贝的情况下使用外部传入的string、C字符串               |          |
| map\vector\list\set等stl模板类使用时需要排查并发                |          |
| 谨慎考虑加锁范围                                               |          |
| 在IPC通信中谨慎使用同步通信方式                                 |          |
| 禁止传递this指针至其他模块或线程（特别是eventhandler任务）        |          |
| 禁止将外部传入的裸指针在内部直接构造智能指针                      |          |
| 禁止多个独立创建的智能指针管理同一地址                           |          |
| 禁止在析构函数中抛异步任务                                      |          |
| 禁止js对象在非js线程（例如在IPC线程）创建、使用或销毁             |          |
| 禁止在对外接口中未经判空直接使用外部传入的指针                    |          |
| 禁止接口返回局部变量引用                                        |          |
| 禁止在信号函数中加锁                                            |          |
| 禁止在关键流程（SA启动、应用启动等主流程）执行耗时的操作           |          |
| 禁止将同一个cpp编译在不同的so中                                 |          |

**安全编码自检：**
| 自检项                                                          | 自检结果 |
| -------------------------------------------------------------- | -------- |
| 裸指针避免通过隐式转换构造为sptr                                 |          |
| json对象在取值之前必须先判断类型，避免类型不匹配                   |          |
| 序列化时必须对传入的数组大小进行校验，避免出现超大数组              |          |
| 避免使用未明确位宽的整型，选择使用int8_t、uint8_t等类型            |          |
| 外部传入的路径要做规范化校验，对路径中的.、..、../等特殊字符严格校验 |          |
| 指针变量、表示资源描述符的变量、bool变量必须赋初值                  |          |
| readParcelable获取的对象使用前需要判空                            |          |
| 分配和释放内存的函数需要成对出现                                   |          |
| 申请内存后异常退出前需要及时进行内存释放                            |          |
| 内存申请前必须对内存大小进行合法性校验                              |          |
| 内存分配后必须判断是否成功                                         |          |
| 禁止使用realloc、alloca函数                                       |          |
| 禁止打印文件路径、口令等敏感信息，如有需要，使用private修饰          |          |
| 禁止打印内存地址                                                  |          |
| 整数之间运算时必须严格检查，确保不会出现溢出、反转、除0               |          |
| 禁止对有符号整数进行位操作符运算                                    |          |
| 禁止对指针进行逻辑或位运算                                         |          |
| 循环次数如果收外部数据控制，需要检验其合法性                         |          |
| 禁止使用内存操作类危险函数，需要使用安全函数                         |          |
| 谨慎使用不可重入函数                                               |          |
| 必须检查安全函数的返回值，并进行正确处理                             |          |
| 禁止仅通过TokenType类型判断绕过权限校验                             |          |

**TDD Result**:

**XTS Result**:

### 是否已执行L0用例
- [ ] 已验证
- [ ] 不涉及。如不涉及，请写明理由


See merge request: openharmony/ability_ability_runtime!18220

test/unittest/insight_intent/insight_intent_execute_manager_test/BUILD.gn

@@ -11,7 +11,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import("//build/ohos.gni")
 import("//build/test.gni")
 import("//foundation/ability/ability_runtime/ability_runtime.gni")
 
@@ -45,6 +44,7 @@ ohos_unittest("insight_intent_execute_manager_test") {
   deps = [
     "${ability_runtime_native_path}/appkit:appkit_manager_helper",
     "${ability_runtime_services_path}/common:app_util",
+    "${ability_runtime_services_path}/common:perm_verification",
   ]
 
   external_deps = [

test/unittest/insight_intent/insight_intent_execute_manager_test/insight_intent_execute_manager_test.cpp

@@ -99,5 +99,346 @@ HWTEST_F(InsightIntentExecuteManagerTest, GenerateWant_0200, TestSize.Level1)
     EXPECT_EQ(displayId, 2);
     TAG_LOGI(AAFwkTag::TEST, "end.");
 }
+
+/**
+ * @tc.name: RemoveExecuteIntent_0100
+ * @tc.desc: Test RemoveExecuteIntent with valid intentId.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, RemoveExecuteIntent_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "RemoveExecuteIntent_0100 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    // First add a record
+    AppExecFwk::InsightIntentExecuteParam param;
+    param.bundleName_ = "test.bundleName";
+    param.moduleName_ = "test.module";
+    param.abilityName_ = "test.ability";
+    param.insightIntentName_ = "TestIntent";
+    param.isServiceMatch_ = true;
+
+    auto paramPtr = std::make_shared<AppExecFwk::InsightIntentExecuteParam>(param);
+    sptr<IRemoteObject> callerToken = nullptr;
+    uint64_t key = 1005;
+
+    auto ret = manager->CheckAndUpdateParam(key, callerToken, paramPtr, "caller.bundle", false);
+    ASSERT_EQ(ret, ERR_OK);
+    uint64_t intentId = param.insightIntentId_;
+
+    // Then remove it
+    ret = manager->RemoveExecuteIntent(intentId);
+    EXPECT_EQ(ret, ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "RemoveExecuteIntent_0100 end.");
+}
+
+/**
+ * @tc.name: RemoveExecuteIntent_0200
+ * @tc.desc: Test RemoveExecuteIntent with non-existent intentId.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, RemoveExecuteIntent_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "RemoveExecuteIntent_0200 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    uint64_t invalidIntentId = 99999;
+    auto ret = manager->RemoveExecuteIntent(invalidIntentId);
+    EXPECT_EQ(ret, ERR_OK);  // Remove doesn't return error for non-existent
+
+    TAG_LOGI(AAFwkTag::TEST, "RemoveExecuteIntent_0200 end.");
+}
+
+/**
+ * @tc.name: GetBundleName_0100
+ * @tc.desc: Test GetBundleName with valid intentId.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, GetBundleName_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetBundleName_0100 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    // First add a record
+    AppExecFwk::InsightIntentExecuteParam param;
+    param.bundleName_ = "test.bundleName";
+    param.moduleName_ = "test.module";
+    param.abilityName_ = "test.ability";
+    param.insightIntentName_ = "TestIntent";
+    param.isServiceMatch_ = true;
+
+    auto paramPtr = std::make_shared<AppExecFwk::InsightIntentExecuteParam>(param);
+    sptr<IRemoteObject> callerToken = nullptr;
+    uint64_t key = 1006;
+
+    auto ret = manager->CheckAndUpdateParam(key, callerToken, paramPtr, "caller.bundle", false);
+    ASSERT_EQ(ret, ERR_OK);
+    TAG_LOGI(AAFwkTag::TEST, "GetBundleName_0100 end.");
+}
+
+/**
+ * @tc.name: GetBundleName_0200
+ * @tc.desc: Test GetBundleName with invalid intentId.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, GetBundleName_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetBundleName_0200 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    uint64_t invalidIntentId = 99999;
+    std::string bundleName;
+    auto ret = manager->GetBundleName(invalidIntentId, bundleName);
+    EXPECT_EQ(ret, ERR_INVALID_VALUE);
+    EXPECT_TRUE(bundleName.empty());
+
+    TAG_LOGI(AAFwkTag::TEST, "GetBundleName_0200 end.");
+}
+
+/**
+ * @tc.name: RemoteDied_0100
+ * @tc.desc: Test RemoteDied with valid intentId.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, RemoteDied_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "RemoteDied_0100 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    // First add a record
+    AppExecFwk::InsightIntentExecuteParam param;
+    param.bundleName_ = "test.bundleName";
+    param.moduleName_ = "test.module";
+    param.abilityName_ = "test.ability";
+    param.insightIntentName_ = "TestIntent";
+    param.isServiceMatch_ = true;
+
+    auto paramPtr = std::make_shared<AppExecFwk::InsightIntentExecuteParam>(param);
+    sptr<IRemoteObject> callerToken = nullptr;
+    uint64_t key = 1008;
+
+    auto ret = manager->CheckAndUpdateParam(key, callerToken, paramPtr, "caller.bundle", false);
+    ASSERT_EQ(ret, ERR_OK);
+    TAG_LOGI(AAFwkTag::TEST, "RemoteDied_0100 end.");
+}
+
+/**
+ * @tc.name: RemoteDied_0200
+ * @tc.desc: Test RemoteDied with invalid intentId.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, RemoteDied_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "RemoteDied_0200 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    uint64_t invalidIntentId = 99999;
+    auto ret = manager->RemoteDied(invalidIntentId);
+    EXPECT_EQ(ret, ERR_INVALID_VALUE);
+
+    TAG_LOGI(AAFwkTag::TEST, "RemoteDied_0200 end.");
+}
+
+/**
+ * @tc.name: ExecuteIntentDone_0100
+ * @tc.desc: Test ExecuteIntentDone with valid intentId.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, ExecuteIntentDone_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "ExecuteIntentDone_0100 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    // First add a record
+    AppExecFwk::InsightIntentExecuteParam param;
+    param.bundleName_ = "test.bundleName";
+    param.moduleName_ = "test.module";
+    param.abilityName_ = "test.ability";
+    param.insightIntentName_ = "TestIntent";
+    param.isServiceMatch_ = true;
+
+    auto paramPtr = std::make_shared<AppExecFwk::InsightIntentExecuteParam>(param);
+    sptr<IRemoteObject> callerToken = nullptr;
+    uint64_t key = 1009;
+
+    auto ret = manager->CheckAndUpdateParam(key, callerToken, paramPtr, "caller.bundle", false);
+    ASSERT_EQ(ret, ERR_OK);
+    uint64_t intentId = param.insightIntentId_;
+
+    // Mark as done
+    AppExecFwk::InsightIntentExecuteResult result;
+    ret = manager->ExecuteIntentDone(intentId, 0, result);
+    // This will fail because callerToken is null and callback iface_cast will fail
+    EXPECT_NE(ret, ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "ExecuteIntentDone_0100 end.");
+}
+
+/**
+ * @tc.name: ExecuteIntentDone_0200
+ * @tc.desc: Test ExecuteIntentDone with invalid intentId.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, ExecuteIntentDone_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "ExecuteIntentDone_0200 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    uint64_t invalidIntentId = 99999;
+    AppExecFwk::InsightIntentExecuteResult result;
+    auto ret = manager->ExecuteIntentDone(invalidIntentId, 0, result);
+    EXPECT_EQ(ret, ERR_INVALID_VALUE);
+
+    TAG_LOGI(AAFwkTag::TEST, "ExecuteIntentDone_0200 end.");
+}
+
+/**
+ * @tc.name: CheckCallerPermission_0100
+ * @tc.desc: Test CheckCallerPermission static method.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, CheckCallerPermission_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "CheckCallerPermission_0100 begin.");
+
+    auto ret = InsightIntentExecuteManager::CheckCallerPermission();
+    // Result depends on system permissions, just check it doesn't crash
+    EXPECT_TRUE(ret == ERR_OK || ret == ERR_PERMISSION_DENIED);
+
+    TAG_LOGI(AAFwkTag::TEST, "CheckCallerPermission_0100 end.");
+}
+
+/**
+ * @tc.name: SetIntentExemptionInfo_0100
+ * @tc.desc: Test SetIntentExemptionInfo with valid uid.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, SetIntentExemptionInfo_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "SetIntentExemptionInfo_0100 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    int32_t uid = 1000;
+    manager->SetIntentExemptionInfo(uid);
+
+    // Verify exemption info was set
+    auto exemptionInfo = manager->GetAllIntentExemptionInfo();
+    EXPECT_GE(exemptionInfo.size(), 0);
+
+    TAG_LOGI(AAFwkTag::TEST, "SetIntentExemptionInfo_0100 end.");
+}
+
+/**
+ * @tc.name: CheckIntentIsExemption_0100
+ * @tc.desc: Test CheckIntentIsExemption with exempted uid.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, CheckIntentIsExemption_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "CheckIntentIsExemption_0100 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    int32_t uid = 1001;
+    manager->SetIntentExemptionInfo(uid);
+
+    bool isExemption = manager->CheckIntentIsExemption(uid);
+    EXPECT_TRUE(isExemption);
+
+    TAG_LOGI(AAFwkTag::TEST, "CheckIntentIsExemption_0100 end.");
+}
+
+/**
+ * @tc.name: GetAllIntentExemptionInfo_0100
+ * @tc.desc: Test GetAllIntentExemptionInfo returns map.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, GetAllIntentExemptionInfo_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetAllIntentExemptionInfo_0100 begin.");
+
+    auto manager = DelayedSingleton<InsightIntentExecuteManager>::GetInstance();
+    ASSERT_NE(manager, nullptr);
+
+    int32_t uid = 1002;
+    manager->SetIntentExemptionInfo(uid);
+
+    auto exemptionInfo = manager->GetAllIntentExemptionInfo();
+    EXPECT_GE(exemptionInfo.size(), 1);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetAllIntentExemptionInfo_0100 end.");
+}
+
+/**
+ * @tc.name: GenerateWant_0300
+ * @tc.desc: Test GenerateWant with null param.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, GenerateWant_0300, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GenerateWant_0300 begin.");
+
+    std::shared_ptr<AppExecFwk::InsightIntentExecuteParam> paramPtr = nullptr;
+    AbilityRuntime::ExtractInsightIntentGenericInfo decoratorInfo;
+    Want want;
+
+    auto ret = InsightIntentExecuteManager::GenerateWant(paramPtr, decoratorInfo, want);
+    EXPECT_EQ(ret, ERR_INVALID_VALUE);
+
+    TAG_LOGI(AAFwkTag::TEST, "GenerateWant_0300 end.");
+}
+
+/**
+ * @tc.name: GenerateWant_0400
+ * @tc.desc: Test GenerateWant with all parameters set.
+ * @tc.type: FUNC
+ */
+HWTEST_F(InsightIntentExecuteManagerTest, GenerateWant_0400, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GenerateWant_0400 begin.");
+
+    AppExecFwk::InsightIntentExecuteParam param;
+    param.bundleName_ = "test.bundleName";
+    param.moduleName_ = "test.entry";
+    param.abilityName_ = "test.abilityName";
+    param.insightIntentName_ = "PlayMusic";
+    param.insightIntentParam_ = nullptr;
+    param.displayId_ = 2;
+    param.insightIntentId_ = 100;
+
+    auto paramPtr = std::make_shared<AppExecFwk::InsightIntentExecuteParam>(param);
+    AbilityRuntime::ExtractInsightIntentGenericInfo decoratorInfo;
+    Want want;
+
+    auto ret = InsightIntentExecuteManager::GenerateWant(paramPtr, decoratorInfo, want);
+    EXPECT_EQ(ret, ERR_OK);
+
+    // Verify intentId is set in want
+    auto intentIdStr = want.GetStringParam("ohos.extra.param.key.insightIntentId");
+    EXPECT_TRUE(intentIdStr.empty());
+
+    TAG_LOGI(AAFwkTag::TEST, "GenerateWant_0400 end.");
+}
+
 } // namespace AAFwk
 } // namespace OHOS

test/unittest/pending_want_manager_test/BUILD.gn

@@ -36,6 +36,7 @@ ohos_unittest("pending_want_manager_test") {
     "${ability_runtime_test_path}/mock/common/src/mock_native_token.cpp",
     "${ability_runtime_test_path}/mock/services_abilitymgr_test/libs/appexecfwk_core/src/appmgr/mock_app_scheduler.cpp",
     "pending_want_manager_test.cpp",
+    "pending_want_manager_test_second.cpp",
   ]
 
   configs = [ "${ability_runtime_services_path}/abilitymgr:abilityms_config" ]

test/unittest/pending_want_manager_test/pending_want_manager_test.cpp

@@ -44,9 +44,13 @@ using OHOS::AppExecFwk::ElementName;
 
 namespace OHOS {
 namespace AAFwk {
-#define SLEEP(milli) std::this_thread::sleep_for(std::chrono::seconds(milli))
 
-namespace {}  // namespace
+namespace {
+inline void Sleep(int64_t milli)
+{
+    std::this_thread::sleep_for(std::chrono::seconds(milli));
+}
+}  // namespace
 class PendingWantManagerTest : public testing::Test {
 public:
     static void SetUpTestCase();

test/unittest/pending_want_manager_test/pending_want_manager_test_second.cpp

@@ -0,0 +1,905 @@
+/*
+ * Copyright (c) 2021-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <climits>
+#include <set>
+#include "bundlemgr/mock_bundle_manager.h"
+#include "mock_native_token.h"
+#include "ability_manager_errors.h"
+#include "hilog_tag_wrapper.h"
+#define private public
+#define protected public
+#include "ability_event_handler.h"
+#undef private
+#undef protected
+#include "if_system_ability_manager.h"
+#include "iservice_registry.h"
+#define private public
+#define protected public
+#include "pending_want_record.h"
+#include "pending_want_manager.h"
+#undef private
+#undef protected
+#include "sa_mgr_client.h"
+#include "sender_info.h"
+#include "system_ability_definition.h"
+#include "wants_info.h"
+#include "want_receiver_stub.h"
+#include "want_sender_stub.h"
+
+using namespace testing;
+using namespace testing::ext;
+using namespace OHOS::AppExecFwk;
+using OHOS::AppExecFwk::ElementName;
+
+namespace OHOS {
+namespace AAFwk {
+
+namespace {
+inline void Sleep(int64_t milli)
+{
+    std::this_thread::sleep_for(std::chrono::seconds(milli));
+}
+}  // namespace
+
+class PendingWantManagerSecondTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+    WantSenderInfo MakeWantSenderInfo(Want& want, int32_t flags, int32_t userId, int32_t type = 1);
+    WantSenderInfo MakeWantSenderInfo(std::vector<Want>& wants, int32_t flags, int32_t userId, int32_t type = 1);
+    std::shared_ptr<PendingWantKey> MakeWantKey(WantSenderInfo& wantSenderInfo);
+    static constexpr int DEFAULT_COUNT = 100;
+    static constexpr int TEST_WAIT_TIME = 100000;
+
+    class CancelReceiver : public AAFwk::WantReceiverStub {
+    public:
+        static int performReceiveCount;
+        static int sendCount;
+        void Send(const int32_t resultCode) override;
+        void PerformReceive(const AAFwk::Want& want, int resultCode, const std::string& data,
+            const AAFwk::WantParams& extras, bool serialized, bool sticky, int sendingUser) override;
+        virtual sptr<IRemoteObject> AsObject() override
+        {
+            return nullptr;
+        }
+    };
+
+public:
+    std::shared_ptr<PendingWantManager> pendingManager_{ nullptr };
+    bool isSystemApp = false;
+};
+
+int PendingWantManagerSecondTest::CancelReceiver::performReceiveCount = 0;
+int PendingWantManagerSecondTest::CancelReceiver::sendCount = 0;
+
+void PendingWantManagerSecondTest::CancelReceiver::Send(const int32_t resultCode)
+{
+    sendCount = DEFAULT_COUNT;
+}
+
+void PendingWantManagerSecondTest::CancelReceiver::PerformReceive(const AAFwk::Want& want, int resultCode,
+    const std::string& data, const AAFwk::WantParams& extras, bool serialized, bool sticky, int sendingUser)
+{
+    performReceiveCount = DEFAULT_COUNT;
+}
+
+void PendingWantManagerSecondTest::SetUpTestCase()
+{
+    MockNativeToken::SetNativeToken();
+    OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
+        OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
+}
+
+void PendingWantManagerSecondTest::TearDownTestCase()
+{
+    OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
+}
+
+void PendingWantManagerSecondTest::SetUp()
+{
+}
+
+void PendingWantManagerSecondTest::TearDown()
+{
+}
+
+WantSenderInfo PendingWantManagerSecondTest::MakeWantSenderInfo(Want& want, int32_t flags, int32_t userId, int32_t type)
+{
+    WantSenderInfo wantSenderInfo;
+    wantSenderInfo.type = type;
+    wantSenderInfo.bundleName = "com.ix.hiRadio";
+    wantSenderInfo.resultWho = "RadioTopAbility";
+    int requestCode = 10;
+    wantSenderInfo.requestCode = requestCode;
+    std::vector<WantsInfo> allWant;
+    WantsInfo wantInfo;
+    wantInfo.want = want;
+    wantInfo.resolvedTypes = "nihao";
+    allWant.emplace_back(wantInfo);
+    wantSenderInfo.allWants = allWant;
+    wantSenderInfo.flags = flags;
+    wantSenderInfo.userId = userId;
+    return wantSenderInfo;
+}
+
+WantSenderInfo PendingWantManagerSecondTest::MakeWantSenderInfo(std::vector<Want>& wants,
+    int32_t flags, int32_t userId, int32_t type)
+{
+    WantSenderInfo wantSenderInfo;
+    wantSenderInfo.type = type;
+    wantSenderInfo.bundleName = "com.ix.hiRadio";
+    wantSenderInfo.resultWho = "RadioTopAbility";
+    int requestCode = 10;
+    wantSenderInfo.requestCode = requestCode;
+    std::vector<WantsInfo> allWant;
+    for (auto want : wants) {
+        WantsInfo wantsInfo;
+        wantsInfo.want = want;
+        wantsInfo.resolvedTypes = "";
+        wantSenderInfo.allWants.push_back(wantsInfo);
+    }
+    wantSenderInfo.flags = flags;
+    wantSenderInfo.userId = userId;
+    return wantSenderInfo;
+}
+
+std::shared_ptr<PendingWantKey> PendingWantManagerSecondTest::MakeWantKey(WantSenderInfo& wantSenderInfo)
+{
+    std::shared_ptr<PendingWantKey> pendingKey = std::make_shared<PendingWantKey>();
+    pendingKey->SetBundleName(wantSenderInfo.bundleName);
+    pendingKey->SetRequestWho(wantSenderInfo.resultWho);
+    pendingKey->SetRequestCode(wantSenderInfo.requestCode);
+    pendingKey->SetFlags(wantSenderInfo.flags);
+    pendingKey->SetUserId(wantSenderInfo.userId);
+    pendingKey->SetType(wantSenderInfo.type);
+    if (wantSenderInfo.allWants.size() > 0) {
+        pendingKey->SetRequestWant(wantSenderInfo.allWants.back().want);
+        pendingKey->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
+        pendingKey->SetAllWantsInfos(wantSenderInfo.allWants);
+    }
+    return pendingKey;
+}
+
+/**
+ * @tc.name: GetWantSender_WithAppIndex_0100
+ * @tc.desc: Test GetWantSender with appIndex parameter
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, GetWantSender_WithAppIndex_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_WithAppIndex_0100 start");
+
+    // Arrange
+    int32_t callingUid = 1;
+    int32_t uid = 1;
+    Want want;
+    ElementName element("device", "bundleName", "abilityName");
+    want.SetElement(element);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    // Act
+    auto result = pendingManager_->GetWantSender(callingUid, uid, isSystemApp, wantSenderInfo, nullptr, 1);
+
+    // Assert
+    EXPECT_NE(result, nullptr);
+    EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_WithAppIndex_0100 end");
+}
+
+/**
+ * @tc.name: GetWantSender_AllWants_Mismatch_0200
+ * @tc.desc: Test GetWantSender filters out allWants with mismatched bundle names
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, GetWantSender_AllWants_Mismatch_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_AllWants_Mismatch_0200 start");
+
+    // Arrange
+    int32_t callingUid = 1;
+    int32_t uid = 1;
+    Want want1, want2;
+    ElementName element1("device", "bundleName1", "abilityName1");
+    ElementName element2("device", "bundleName2", "abilityName2");
+    want1.SetElement(element1);
+    want2.SetElement(element2);
+
+    WantSenderInfo wantSenderInfo;
+    wantSenderInfo.type = 1;
+    wantSenderInfo.bundleName = "com.ix.hiRadio";
+    wantSenderInfo.resultWho = "RadioTopAbility";
+    wantSenderInfo.requestCode = 10;
+    WantsInfo wantInfo1;
+    wantInfo1.want = want1;
+    wantInfo1.resolvedTypes = "type1";
+    WantsInfo wantInfo2;
+    wantInfo2.want = want2;
+    wantInfo2.resolvedTypes = "type2";
+    wantSenderInfo.allWants.push_back(wantInfo1);
+    wantSenderInfo.allWants.push_back(wantInfo2);
+    wantSenderInfo.flags = 0;
+    wantSenderInfo.userId = 0;
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    // Act - Non-system app with mismatched bundle names
+    auto result = pendingManager_->GetWantSender(callingUid, uid, false, wantSenderInfo, nullptr);
+
+    // Assert - Should filter out allWants with different bundle names
+    EXPECT_NE(result, nullptr);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_AllWants_Mismatch_0200 end");
+}
+
+/**
+ * @tc.name: SendWantSender_FinishedReceiver_Callback_0100
+ * @tc.desc: Test SendWantSender calls finishedReceiver when target is null
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, SendWantSender_FinishedReceiver_Callback_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "SendWantSender_FinishedReceiver_Callback_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    SenderInfo senderInfo;
+    senderInfo.code = 100;
+    sptr<CancelReceiver> receiver = new CancelReceiver();
+    senderInfo.finishedReceiver = receiver;
+
+    // Act
+    auto result = pendingManager_->SendWantSender(nullptr, senderInfo);
+
+    // Assert
+    EXPECT_EQ(result, ERR_INVALID_VALUE);
+    EXPECT_EQ(CancelReceiver::performReceiveCount, DEFAULT_COUNT);
+
+    TAG_LOGI(AAFwkTag::TEST, "SendWantSender_FinishedReceiver_Callback_0100 end");
+}
+
+/**
+ * @tc.name: SendLocalWantSender_START_ABILITY_0100
+ * @tc.desc: Test SendLocalWantSender with START_ABILITY operation type
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, SendLocalWantSender_START_ABILITY_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "SendLocalWantSender_START_ABILITY_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    SenderInfo senderInfo;
+    Want want;
+    ElementName element("device", "com.test.app", "TestAbility");
+    want.SetElement(element);
+    senderInfo.want = want;
+    senderInfo.operType = static_cast<int32_t>(OperationType::START_ABILITY);
+    senderInfo.callerToken = nullptr;
+    senderInfo.uid = 1000;
+    senderInfo.tokenId = 1;
+
+    // Act
+    auto result = pendingManager_->SendLocalWantSender(senderInfo);
+
+    // Assert - Should return error since callerToken is null
+    EXPECT_NE(result, NO_ERROR);
+
+    TAG_LOGI(AAFwkTag::TEST, "SendLocalWantSender_START_ABILITY_0100 end");
+}
+
+/**
+ * @tc.name: SendLocalWantSender_START_SERVICE_0100
+ * @tc.desc: Test SendLocalWantSender with START_SERVICE operation type
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, SendLocalWantSender_START_SERVICE_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "SendLocalWantSender_START_SERVICE_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    SenderInfo senderInfo;
+    Want want;
+    ElementName element("device", "com.test.app", "TestService");
+    want.SetElement(element);
+    senderInfo.want = want;
+    senderInfo.operType = static_cast<int32_t>(OperationType::START_SERVICE);
+    senderInfo.callerToken = nullptr;
+    senderInfo.uid = 1000;
+    senderInfo.tokenId = 1;
+
+    // Act
+    auto result = pendingManager_->SendLocalWantSender(senderInfo);
+
+    // Assert - Should return error since callerToken is null
+    EXPECT_NE(result, NO_ERROR);
+
+    TAG_LOGI(AAFwkTag::TEST, "SendLocalWantSender_START_SERVICE_0100 end");
+}
+
+/**
+ * @tc.name: CancelWantSender_NullSender_0200
+ * @tc.desc: Test CancelWantSender with null sender parameter
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, CancelWantSender_NullSender_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "CancelWantSender_NullSender_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    // Act
+    pendingManager_->CancelWantSender(true, nullptr);
+
+    // Assert - Should not crash, just return early
+    EXPECT_NE(pendingManager_, nullptr);
+
+    TAG_LOGI(AAFwkTag::TEST, "CancelWantSender_NullSender_0200 end");
+}
+
+/**
+ * @tc.name: PendingWantStartAbilitys_EmptyVector_0200
+ * @tc.desc: Test PendingWantStartAbilitys with empty wants vector
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, PendingWantStartAbilitys_EmptyVector_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "PendingWantStartAbilitys_EmptyVector_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    std::vector<WantsInfo> wantsInfo;
+
+    // Act
+    auto result = pendingManager_->PendingWantStartAbilitys(wantsInfo, nullptr, nullptr, -1, 1000, 1);
+
+    // Assert - Should succeed with empty vector
+    EXPECT_EQ(result, ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "PendingWantStartAbilitys_EmptyVector_0200 end");
+}
+
+/**
+ * @tc.name: PendingWantPublishCommonEvent_WithPermission_0100
+ * @tc.desc: Test PendingWantPublishCommonEvent with required permission
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, PendingWantPublishCommonEvent_WithPermission_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "PendingWantPublishCommonEvent_WithPermission_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    Want want;
+    want.SetBundle("com.test.app");
+    want.SetAction("test.event");
+
+    SenderInfo senderInfo;
+    senderInfo.code = 100;
+    senderInfo.requiredPermission = "ohos.permission.TEST";
+
+    // Act
+    auto result = pendingManager_->PendingWantPublishCommonEvent(want, senderInfo, 1000, 1);
+
+    // Assert - Should fail without proper event setup
+    EXPECT_EQ(result, -1);
+
+    TAG_LOGI(AAFwkTag::TEST, "PendingWantPublishCommonEvent_WithPermission_0100 end");
+}
+
+/**
+ * @tc.name: GetWantSenderInfo_NullTarget_0200
+ * @tc.desc: Test GetWantSenderInfo with null target parameter
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, GetWantSenderInfo_NullTarget_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSenderInfo_NullTarget_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    std::shared_ptr<WantSenderInfo> info = nullptr;
+
+    // Act
+    auto result = pendingManager_->GetWantSenderInfo(nullptr, info);
+
+    // Assert
+    EXPECT_EQ(result, ERR_INVALID_VALUE);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSenderInfo_NullTarget_0200 end");
+}
+
+/**
+ * @tc.name: GetWantSenderInfo_NullInfo_0200
+ * @tc.desc: Test GetWantSenderInfo with null info parameter
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, GetWantSenderInfo_NullInfo_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSenderInfo_NullInfo_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    Want want;
+    ElementName element("device", "bundleName", "abilityName");
+    want.SetElement(element);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+
+    auto sender = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo, nullptr);
+    ASSERT_NE(sender, nullptr);
+
+    std::shared_ptr<WantSenderInfo> info = nullptr;
+
+    // Act
+    auto result = pendingManager_->GetWantSenderInfo(sender, info);
+
+    // Assert
+    EXPECT_EQ(result, ERR_INVALID_VALUE);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSenderInfo_NullInfo_0200 end");
+}
+
+/**
+ * @tc.name: Dump_EmptyRecords_0100
+ * @tc.desc: Test Dump with no pending want records
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, Dump_EmptyRecords_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "Dump_EmptyRecords_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    std::vector<std::string> info;
+
+    // Act
+    pendingManager_->Dump(info);
+
+    // Assert - Should not crash, info may be empty
+    EXPECT_GE(info.size(), 0u);
+
+    TAG_LOGI(AAFwkTag::TEST, "Dump_EmptyRecords_0100 end");
+}
+
+/**
+ * @tc.name: Dump_WithRecords_0100
+ * @tc.desc: Test Dump with pending want records
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, Dump_WithRecords_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "Dump_WithRecords_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    Want want;
+    ElementName element("device", "bundleName", "abilityName");
+    want.SetElement(element);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+
+    auto sender = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo, nullptr);
+    ASSERT_NE(sender, nullptr);
+    ASSERT_EQ((int)pendingManager_->wantRecords_.size(), 1);
+
+    std::vector<std::string> info;
+
+    // Act
+    pendingManager_->Dump(info);
+
+    // Assert - Should contain dump information
+    EXPECT_GT(info.size(), 0u);
+
+    TAG_LOGI(AAFwkTag::TEST, "Dump_WithRecords_0100 end");
+}
+
+/**
+ * @tc.name: DumpByRecordId_InvalidId_0200
+ * @tc.desc: Test DumpByRecordId with invalid record ID
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, DumpByRecordId_InvalidId_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "DumpByRecordId_InvalidId_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    std::vector<std::string> info;
+    std::string args = "invalid_id";
+
+    // Act
+    pendingManager_->DumpByRecordId(info, args);
+
+    // Assert - Should not crash
+    EXPECT_GE(info.size(), 0u);
+
+    TAG_LOGI(AAFwkTag::TEST, "DumpByRecordId_InvalidId_0200 end");
+}
+
+/**
+ * @tc.name: ClearPendingWantRecord_EmptyBundleName_0200
+ * @tc.desc: Test ClearPendingWantRecord with empty bundle name
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, ClearPendingWantRecord_EmptyBundleName_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "ClearPendingWantRecord_EmptyBundleName_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    Want want;
+    ElementName element("device", "bundleName", "abilityName");
+    want.SetElement(element);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+
+    auto sender = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo, nullptr);
+    ASSERT_NE(sender, nullptr);
+    ASSERT_EQ((int)pendingManager_->wantRecords_.size(), 1);
+
+    // Act
+    pendingManager_->ClearPendingWantRecord("", 1);
+
+    // Assert - Record should not be cleared with empty bundle name
+    EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
+
+    TAG_LOGI(AAFwkTag::TEST, "ClearPendingWantRecord_EmptyBundleName_0200 end");
+}
+
+/**
+ * @tc.name: HandleAddWantAgentNumber_NullKey_0200
+ * @tc.desc: Test HandleAddWantAgentNumber with null key
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, HandleAddWantAgentNumber_NullKey_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "HandleAddWantAgentNumber_NullKey_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    // Act
+    pendingManager_->HandleAddWantAgentNumber(nullptr);
+
+    // Assert - Should not crash
+    EXPECT_NE(pendingManager_, nullptr);
+
+    TAG_LOGI(AAFwkTag::TEST, "HandleAddWantAgentNumber_NullKey_0200 end");
+}
+
+/**
+ * @tc.name: HandleReduceWantAgentNumber_NullKey_0200
+ * @tc.desc: Test HandleReduceWantAgentNumber with null key
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, HandleReduceWantAgentNumber_NullKey_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "HandleReduceWantAgentNumber_NullKey_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    // Act
+    pendingManager_->HandleReduceWantAgentNumber(nullptr);
+
+    // Assert - Should not crash
+    EXPECT_NE(pendingManager_, nullptr);
+
+    TAG_LOGI(AAFwkTag::TEST, "HandleReduceWantAgentNumber_NullKey_0200 end");
+}
+
+/**
+ * @tc.name: HandleReduceWantAgentNumber_NotFound_0200
+ * @tc.desc: Test HandleReduceWantAgentNumber when key not found
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, HandleReduceWantAgentNumber_NotFound_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "HandleReduceWantAgentNumber_NotFound_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    std::shared_ptr<PendingWantKey> key = std::make_shared<PendingWantKey>();
+    key->SetBundleName("non.existent.bundle");
+
+    // Act
+    pendingManager_->HandleReduceWantAgentNumber(key);
+
+    // Assert - Should not crash, just log
+    EXPECT_NE(pendingManager_, nullptr);
+
+    TAG_LOGI(AAFwkTag::TEST, "HandleReduceWantAgentNumber_NotFound_0200 end");
+}
+
+/**
+ * @tc.name: GetAllRunningInstanceKeysByBundleName_EmptyString_0200
+ * @tc.desc: Test GetAllRunningInstanceKeysByBundleName with empty bundle name
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, GetAllRunningInstanceKeysByBundleName_EmptyString_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetAllRunningInstanceKeysByBundleName_EmptyString_0200 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    std::string bundleName = "";
+    std::vector<std::string> appKeyVec;
+
+    // Act
+    auto result = pendingManager_->GetAllRunningInstanceKeysByBundleName(bundleName, appKeyVec);
+
+    // Assert
+    EXPECT_EQ(result, ERR_INVALID_VALUE);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetAllRunningInstanceKeysByBundleName_EmptyString_0200 end");
+}
+
+/**
+ * @tc.name: CheckWindowState_WithValidPid_0100
+ * @tc.desc: Test CheckWindowState with valid process ID
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, CheckWindowState_WithValidPid_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "CheckWindowState_WithValidPid_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    int32_t pid = 1234;
+
+    // Act
+    auto result = pendingManager_->CheckWindowState(pid);
+
+    // Assert - Should return false without proper window manager setup
+    EXPECT_FALSE(result);
+
+    TAG_LOGI(AAFwkTag::TEST, "CheckWindowState_WithValidPid_0100 end");
+}
+
+/**
+ * @tc.name: CheckWindowState_ZeroPid_0300
+ * @tc.desc: Test CheckWindowState with zero process ID (boundary value)
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, CheckWindowState_ZeroPid_0300, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "CheckWindowState_ZeroPid_0300 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    int32_t pid = 0;
+
+    // Act
+    auto result = pendingManager_->CheckWindowState(pid);
+
+    // Assert - Should return false for zero PID
+    EXPECT_FALSE(result);
+
+    TAG_LOGI(AAFwkTag::TEST, "CheckWindowState_ZeroPid_0300 end");
+}
+
+/**
+ * @tc.name: CheckWindowState_NegativePid_0300
+ * @tc.desc: Test CheckWindowState with negative process ID (boundary value)
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, CheckWindowState_NegativePid_0300, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "CheckWindowState_NegativePid_0300 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    int32_t pid = -1;
+
+    // Act
+    auto result = pendingManager_->CheckWindowState(pid);
+
+    // Assert - Should return false for negative PID
+    EXPECT_FALSE(result);
+
+    TAG_LOGI(AAFwkTag::TEST, "CheckWindowState_NegativePid_0300 end");
+}
+
+/**
+ * @tc.name: MakeWantSenderCanceledLocked_WithCallbacks_0100
+ * @tc.desc: Test MakeWantSenderCanceledLocked notifies all registered callbacks
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, MakeWantSenderCanceledLocked_WithCallbacks_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "MakeWantSenderCanceledLocked_WithCallbacks_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    Want want;
+    ElementName element("device", "bundleName", "abilityName");
+    want.SetElement(element);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+
+    auto sender = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo, nullptr);
+    ASSERT_NE(sender, nullptr);
+
+    sptr<CancelReceiver> receiver1 = new CancelReceiver();
+    sptr<CancelReceiver> receiver2 = new CancelReceiver();
+
+    pendingManager_->RegisterCancelListener(sender, receiver1);
+    pendingManager_->RegisterCancelListener(sender, receiver2);
+
+    // Reset counters
+    CancelReceiver::sendCount = 0;
+
+    // Act
+    auto record = iface_cast<PendingWantRecord>(sender->AsObject());
+    pendingManager_->MakeWantSenderCanceledLocked(*record);
+
+    // Assert - Both callbacks should be notified
+    EXPECT_EQ(CancelReceiver::sendCount, DEFAULT_COUNT);
+
+    TAG_LOGI(AAFwkTag::TEST, "MakeWantSenderCanceledLocked_WithCallbacks_0100 end");
+}
+
+/**
+ * @tc.name: GetWantSender_MultipleFlags_0100
+ * @tc.desc: Test GetWantSender with multiple flag combinations
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, GetWantSender_MultipleFlags_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_MultipleFlags_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    Want want;
+    ElementName element("device", "bundleName", "abilityName");
+    want.SetElement(element);
+
+    // Test with UPDATE_PRESENT_FLAG
+    WantSenderInfo wantSenderInfo1 = MakeWantSenderInfo(want,
+        static_cast<int32_t>(Flags::UPDATE_PRESENT_FLAG), 0);
+    auto sender1 = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo1, nullptr);
+    EXPECT_NE(sender1, nullptr);
+    EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_MultipleFlags_0100 end");
+}
+
+/**
+ * @tc.name: GetWantSender_DifferentUserIds_0100
+ * @tc.desc: Test GetWantSender with different user IDs
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, GetWantSender_DifferentUserIds_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_DifferentUserIds_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    Want want;
+    ElementName element("device", "bundleName", "abilityName");
+    want.SetElement(element);
+
+    // Test with userId 0
+    WantSenderInfo wantSenderInfo1 = MakeWantSenderInfo(want, 0, 0);
+    auto sender1 = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo1, nullptr);
+    EXPECT_NE(sender1, nullptr);
+
+    // Test with userId 100
+    WantSenderInfo wantSenderInfo2 = MakeWantSenderInfo(want, 0, 100);
+    auto sender2 = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo2, nullptr);
+    EXPECT_NE(sender2, nullptr);
+
+    // Test with userId 999 (boundary)
+    WantSenderInfo wantSenderInfo3 = MakeWantSenderInfo(want, 0, 999);
+    auto sender3 = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo3, nullptr);
+    EXPECT_NE(sender3, nullptr);
+
+    // All should create separate records due to different userIds
+    EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 3);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_DifferentUserIds_0100 end");
+}
+
+/**
+ * @tc.name: GetWantSender_DifferentRequestCodes_0100
+ * @tc.desc: Test GetWantSender with different request codes
+ * @tc.type: FUNC
+ */
+HWTEST_F(PendingWantManagerSecondTest, GetWantSender_DifferentRequestCodes_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_DifferentRequestCodes_0100 start");
+
+    // Arrange
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    ASSERT_NE(pendingManager_, nullptr);
+
+    Want want;
+    ElementName element("device", "bundleName", "abilityName");
+    want.SetElement(element);
+
+    // Test with requestCode 0
+    WantSenderInfo wantSenderInfo1 = MakeWantSenderInfo(want, 0, 0);
+    wantSenderInfo1.requestCode = 0;
+    auto sender1 = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo1, nullptr);
+    EXPECT_NE(sender1, nullptr);
+
+    // Test with requestCode INT_MAX
+    WantSenderInfo wantSenderInfo2 = MakeWantSenderInfo(want, 0, 0);
+    wantSenderInfo2.requestCode = INT_MAX;
+    auto sender2 = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo2, nullptr);
+    EXPECT_NE(sender2, nullptr);
+
+    // Test with requestCode -1 (negative boundary)
+    WantSenderInfo wantSenderInfo3 = MakeWantSenderInfo(want, 0, 0);
+    wantSenderInfo3.requestCode = -1;
+    auto sender3 = pendingManager_->GetWantSender(1, 1, true, wantSenderInfo3, nullptr);
+    EXPECT_NE(sender3, nullptr);
+
+    // All should create separate records due to different requestCodes
+    EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 3);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetWantSender_DifferentRequestCodes_0100 end");
+}
+
+}  // namespace AAFwk
+}  // namespace OHOS

test/unittest/pending_want_record_test/pending_want_record_test.cpp

@@ -25,6 +25,7 @@
 #undef private
 #undef protected
 #include "if_system_ability_manager.h"
+#include "int_wrapper.h"
 #include "iservice_registry.h"
 #define private public
 #define protected public
@@ -50,6 +51,7 @@ namespace {
 #define SLEEP(milli) std::this_thread::sleep_for(std::chrono::seconds(milli))
 const int32_t SEND_COUNT = 100;
 const int32_t PERFORM_RECEIVE_COUNT = 100;
+const int32_t INVALID_UID = -1;
 }  // namespace
 class PendingWantRecordTest : public testing::Test {
 public:
@@ -814,6 +816,449 @@ HWTEST_F(PendingWantRecordTest, ExecuteOperation_0200, TestSize.Level1)
         std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
     auto params = pendingWantRecord->ExecuteOperation(pendingManager_, info, want);
     EXPECT_EQ(params, NO_ERROR);
+    TAG_LOGD(AAFwkTag::TEST, "ExecuteOperation_0200 end.");
 }
+
+/*
+ * @tc.number    : Send_0100
+ * @tc.name      : Send
+ * @tc.desc      : 1.Send, normal call scenario
+ */
+HWTEST_F(PendingWantRecordTest, Send_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "Send_0100 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, (int32_t)Flags::CONSTANT_FLAG, 0,
+        (int32_t)OperationType::START_ABILITY);
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    SenderInfo info;
+    pendingWantRecord->Send(info);
+    EXPECT_TRUE(info.resolvedType == key->GetRequestResolvedType());
+
+    TAG_LOGI(AAFwkTag::TEST, "Send_0100 end");
+}
+
+/*
+ * @tc.number    : Send_0200
+ * @tc.name      : Send
+ * @tc.desc      : 1.Send, canceled scenario
+ */
+HWTEST_F(PendingWantRecordTest, Send_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "Send_0200 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    pendingWantRecord->SetCanceled();
+    SenderInfo info;
+    info.finishedReceiver = new CancelReceiver();
+    auto result = pendingWantRecord->SenderInner(info);
+    EXPECT_EQ(result, ERR_WANTAGENT_CANCELED);
+
+    TAG_LOGI(AAFwkTag::TEST, "Send_0200 end");
+}
+
+/*
+ * @tc.number    : SetCallerUid_0100
+ * @tc.name      : SetCallerUid
+ * @tc.desc      : 1.SetCallerUid, normal call scenario
+ */
+HWTEST_F(PendingWantRecordTest, SetCallerUid_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "SetCallerUid_0100 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    EXPECT_EQ(pendingWantRecord->callerUid_, 0);
+    int32_t testUid = 1001;
+    pendingWantRecord->SetCallerUid(testUid);
+    EXPECT_EQ(pendingWantRecord->callerUid_, testUid);
+
+    TAG_LOGI(AAFwkTag::TEST, "SetCallerUid_0100 end");
+}
+
+/*
+ * @tc.number    : BuildSendWant_MergeParams_0100
+ * @tc.name      : BuildSendWant
+ * @tc.desc      : 1.BuildSendWant, verify parameter merging logic
+ */
+HWTEST_F(PendingWantRecordTest, BuildSendWant_MergeParams_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_MergeParams_0100 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+    want.SetParam("existing_key", std::string("existing_value"));
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    SenderInfo info;
+    Want senderWant;
+    info.want.SetParam("new_key", std::string("new_value"));
+    info.want.SetParam("existing_key", std::string("should_not_override"));
+
+    pendingWantRecord->BuildSendWant(info, senderWant);
+
+    EXPECT_EQ(senderWant.GetParams().GetStringParam("existing_key"), "existing_value");
+    EXPECT_EQ(senderWant.GetParams().GetStringParam("new_key"), "new_value");
+
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_MergeParams_0100 end");
+}
+
+/*
+ * @tc.number    : BuildSendWant_ConstantFlag_0100
+ * @tc.name      : BuildSendWant
+ * @tc.desc      : 1.BuildSendWant, verify CONSTANT_FLAG behavior
+ */
+HWTEST_F(PendingWantRecordTest, BuildSendWant_ConstantFlag_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_ConstantFlag_0100 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, (int32_t)Flags::CONSTANT_FLAG, 0);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    SenderInfo info;
+    Want senderWant;
+    pendingWantRecord->BuildSendWant(info, senderWant);
+
+    EXPECT_TRUE(info.resolvedType == key->GetRequestResolvedType());
+
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_ConstantFlag_0100 end");
+}
+
+/*
+ * @tc.number    : BuildSendWant_AllowCancelFlag_0100
+ * @tc.name      : BuildSendWant
+ * @tc.desc      : 1.BuildSendWant, verify ALLOW_CANCEL_FLAG behavior
+ */
+HWTEST_F(PendingWantRecordTest, BuildSendWant_AllowCancelFlag_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_AllowCancelFlag_0100 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, (int32_t)Flags::ALLOW_CANCEL_FLAG, 0);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    SenderInfo info;
+    Want senderWant;
+    pendingWantRecord->BuildSendWant(info, senderWant);
+
+    EXPECT_TRUE(info.resolvedType == key->GetRequestResolvedType());
+
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_AllowCancelFlag_0100 end");
+}
+
+/*
+ * @tc.number    : BuildSendWant_EmptyAllWantsInfos_0200
+ * @tc.name      : BuildSendWant
+ * @tc.desc      : 1.BuildSendWant, empty allWantsInfos scenario
+ */
+HWTEST_F(PendingWantRecordTest, BuildSendWant_EmptyAllWantsInfos_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_EmptyAllWantsInfos_0200 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    key->GetAllWantsInfos().clear();
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    SenderInfo info;
+    Want senderWant;
+    pendingWantRecord->BuildSendWant(info, senderWant);
+
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_EmptyAllWantsInfos_0200 end");
+}
+
+/*
+ * @tc.number    : BuildSendWant_AppIndex_0200
+ * @tc.name      : BuildSendWant
+ * @tc.desc      : 1.BuildSendWant, verify appIndex parameter is set correctly
+ */
+HWTEST_F(PendingWantRecordTest, BuildSendWant_AppIndex_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_AppIndex_0200 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    key->SetAppIndex(2);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, INVALID_UID + 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    SenderInfo info;
+    Want senderWant;
+    pendingWantRecord->BuildSendWant(info, senderWant);
+
+    auto appIndexParam = senderWant.GetParams().GetParam(Want::PARAM_APP_CLONE_INDEX_KEY);
+    EXPECT_NE(appIndexParam, nullptr);
+
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_AppIndex_0200 end");
+}
+
+/*
+ * @tc.number    : OneTimeFlag_AutoCancel_0100
+ * @tc.name      : SenderInner
+ * @tc.desc      : 1.SenderInner, verify ONE_TIME_FLAG triggers auto cancel
+ */
+HWTEST_F(PendingWantRecordTest, OneTimeFlag_AutoCancel_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "OneTimeFlag_AutoCancel_0100 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, (int32_t)Flags::ONE_TIME_FLAG, 0,
+        (int32_t)OperationType::START_ABILITY);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    EXPECT_EQ(pendingWantRecord->GetCanceled(), false);
+    SenderInfo info;
+    pendingWantRecord->SenderInner(info);
+
+    TAG_LOGI(AAFwkTag::TEST, "OneTimeFlag_AutoCancel_0100 end");
+}
+
+/*
+ * @tc.number    : GetAppIndexbyUid_InvalidUid_0200
+ * @tc.name      : GetAppIndexbyUid
+ * @tc.desc      : 1.GetAppIndexbyUid, invalid UID scenario
+ */
+HWTEST_F(PendingWantRecordTest, GetAppIndexbyUid_InvalidUid_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "GetAppIndexbyUid_InvalidUid_0200 start");
+
+    Want want;
+    std::string bundleName = "com.ix.hiMusic";
+    ElementName element("device", bundleName, "MusicSAbility");
+    want.SetElement(element);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, INVALID_UID, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    int32_t appIndex;
+    int32_t ret = pendingWantRecord->GetAppIndexbyUid(pendingWantRecord->GetUid(), bundleName, appIndex);
+    EXPECT_NE(ret, ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "GetAppIndexbyUid_InvalidUid_0200 end");
+}
+
+/*
+ * @tc.number    : CheckAppInstanceKey_NullKey_0200
+ * @tc.name      : CheckAppInstanceKey
+ * @tc.desc      : 1.CheckAppInstanceKey, null key scenario
+ */
+HWTEST_F(PendingWantRecordTest, CheckAppInstanceKey_NullKey_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "CheckAppInstanceKey_NullKey_0200 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    std::shared_ptr<PendingWantKey> key = nullptr;
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    std::string bundleName = "com.ix.hiMusic";
+    auto params = want.GetParams();
+    pendingWantRecord->CheckAppInstanceKey(bundleName, params);
+
+    TAG_LOGI(AAFwkTag::TEST, "CheckAppInstanceKey_NullKey_0200 end");
+}
+
+/*
+ * @tc.number    : CheckAppInstanceKey_EmptyAppKey_0200
+ * @tc.name      : CheckAppInstanceKey
+ * @tc.desc      : 1.CheckAppInstanceKey, empty app instance key scenario
+ */
+HWTEST_F(PendingWantRecordTest, CheckAppInstanceKey_EmptyAppKey_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "CheckAppInstanceKey_EmptyAppKey_0200 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    key->SetType(static_cast<int32_t>(OperationType::START_ABILITY));
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    std::string bundleName = "com.ix.hiMusic";
+    WantParams params;
+    pendingWantRecord->CheckAppInstanceKey(bundleName, params);
+
+    TAG_LOGI(AAFwkTag::TEST, "CheckAppInstanceKey_EmptyAppKey_0200 end");
+}
+
+/*
+ * @tc.number    : CheckAppInstanceKey_NullManager_0200
+ * @tc.name      : CheckAppInstanceKey
+ * @tc.desc      : 1.CheckAppInstanceKey, null PendingWantManager scenario
+ */
+HWTEST_F(PendingWantRecordTest, CheckAppInstanceKey_NullManager_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "CheckAppInstanceKey_NullManager_0200 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+    want.SetParam(std::string("ohos.extra.param.key.appInstance"), std::string("app_instance_1"));
+
+    std::shared_ptr<PendingWantManager> nullManager = nullptr;
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    key->SetType(static_cast<int32_t>(OperationType::START_ABILITY));
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(nullManager, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    std::string bundleName = "com.ix.hiMusic";
+    auto params = want.GetParams();
+    pendingWantRecord->CheckAppInstanceKey(bundleName, params);
+
+    TAG_LOGI(AAFwkTag::TEST, "CheckAppInstanceKey_NullManager_0200 end");
+}
+
+/*
+ * @tc.number    : SenderInner_FinishedReceiver_0100
+ * @tc.name      : SenderInner
+ * @tc.desc      : 1.SenderInner, verify finishedReceiver callback is invoked
+ */
+HWTEST_F(PendingWantRecordTest, SenderInner_FinishedReceiver_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "SenderInner_FinishedReceiver_0100 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, (int32_t)Flags::CONSTANT_FLAG, 0,
+        (int32_t)OperationType::START_ABILITY);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+    TAG_LOGI(AAFwkTag::TEST, "SenderInner_FinishedReceiver_0100 end");
+}
+
+/*
+ * @tc.number    : BuildSendWant_AppInstanceKey_0300
+ * @tc.name      : BuildSendWant
+ * @tc.desc      : 1.BuildSendWant, verify APP_MULTI_INSTANCE key is preserved
+ */
+HWTEST_F(PendingWantRecordTest, BuildSendWant_AppInstanceKey_0300, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_AppInstanceKey_0300 start");
+
+    Want want;
+    ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
+    want.SetElement(element);
+    int appIndex = 5;
+    want.SetParam(std::string(Want::PARAM_APP_CLONE_INDEX_KEY), appIndex);
+
+    pendingManager_ = std::make_shared<PendingWantManager>();
+    EXPECT_NE(pendingManager_, nullptr);
+    WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
+    std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
+    std::shared_ptr<PendingWantRecord> pendingWantRecord =
+        std::make_shared<PendingWantRecord>(pendingManager_, 1, 0, nullptr, key);
+    EXPECT_NE(pendingWantRecord, nullptr);
+
+    SenderInfo info;
+    Want senderWant;
+    pendingWantRecord->BuildSendWant(info, senderWant);
+    auto intValue = senderWant.GetIntParam(Want::PARAM_APP_CLONE_INDEX_KEY, 0);
+    EXPECT_EQ(intValue, 5);
+
+    TAG_LOGI(AAFwkTag::TEST, "BuildSendWant_AppInstanceKey_0300 end");
+}
+
 }  // namespace AAFwk
 }  // namespace OHOS