diff --git a/test/unittest/cstest/cs1_test.cpp b/test/unittest/cstest/cs1_test.cpp
index fe1cb3d0de92d553a5f2f5161154f15de90fb1ad..f6362344ed149230b742b747cda3964f5bf31f85 100644
--- a/test/unittest/cstest/cs1_test.cpp
+++ b/test/unittest/cstest/cs1_test.cpp
@@ -222,36 +222,34 @@ HWTEST_F(Cs1Test, cellular_call_SetEmergencyCallList_0101, Function | MediumTest
     auto telephonyService = iface_cast<CellularCallInterface>(emergencyRemote);
     ASSERT_TRUE(telephonyService != nullptr);
 
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    std::vector<EmergencyCall> eccVec;
-    EmergencyCall temp0 = { "499", "460", EccType::TYPE_CATEGORY, SimpresentType::TYPE_NO_CARD,
-        AbnormalServiceType::TYPE_ALL };
-    EmergencyCall temp1 = { "443", "460", EccType::TYPE_POLICE, SimpresentType::TYPE_NO_CARD,
-        AbnormalServiceType::TYPE_ALL };
-    EmergencyCall temp2 = { "356", "460", EccType::TYPE_AMBULANCE, SimpresentType::TYPE_NO_CARD,
-        AbnormalServiceType::TYPE_ALL };
-    EmergencyCall temp3 = { "783", "460", EccType::TYPE_FIRE, SimpresentType::TYPE_NO_CARD,
-        AbnormalServiceType::TYPE_ALL };
-    EmergencyCall temp4 = { "975", "460", EccType::TYPE_SEA, SimpresentType::TYPE_HAS_CARD,
-        AbnormalServiceType::TYPE_ONLY_CS };
-    EmergencyCall temp5 = { "350", "460", EccType::TYPE_MOUNTAIN, SimpresentType::TYPE_HAS_CARD,
-        AbnormalServiceType::TYPE_ALL };
-    eccVec.push_back(temp0);
-    eccVec.push_back(temp1);
-    eccVec.push_back(temp2);
-    eccVec.push_back(temp3);
-    eccVec.push_back(temp4);
-    eccVec.push_back(temp5);
-    if (HasSimCard(SIM1_SLOTID)) {
-        EXPECT_EQ(telephonyService->SetEmergencyCallList(SIM1_SLOTID, eccVec), 0);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        EXPECT_EQ(telephonyService->SetEmergencyCallList(SIM2_SLOTID, eccVec), 0);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        std::vector<EmergencyCall> eccVec;
+        EmergencyCall temp0 = { "499", "460", EccType::TYPE_CATEGORY, SimpresentType::TYPE_NO_CARD,
+            AbnormalServiceType::TYPE_ALL };
+        EmergencyCall temp1 = { "443", "460", EccType::TYPE_POLICE, SimpresentType::TYPE_NO_CARD,
+            AbnormalServiceType::TYPE_ALL };
+        EmergencyCall temp2 = { "356", "460", EccType::TYPE_AMBULANCE, SimpresentType::TYPE_NO_CARD,
+            AbnormalServiceType::TYPE_ALL };
+        EmergencyCall temp3 = { "783", "460", EccType::TYPE_FIRE, SimpresentType::TYPE_NO_CARD,
+            AbnormalServiceType::TYPE_ALL };
+        EmergencyCall temp4 = { "975", "460", EccType::TYPE_SEA, SimpresentType::TYPE_HAS_CARD,
+            AbnormalServiceType::TYPE_ONLY_CS };
+        EmergencyCall temp5 = { "350", "460", EccType::TYPE_MOUNTAIN, SimpresentType::TYPE_HAS_CARD,
+            AbnormalServiceType::TYPE_ALL };
+        eccVec.push_back(temp0);
+        eccVec.push_back(temp1);
+        eccVec.push_back(temp2);
+        eccVec.push_back(temp3);
+        eccVec.push_back(temp4);
+        eccVec.push_back(temp5);
+        if (HasSimCard(SIM1_SLOTID)) {
+            EXPECT_EQ(telephonyService->SetEmergencyCallList(SIM1_SLOTID, eccVec), 0);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            EXPECT_EQ(telephonyService->SetEmergencyCallList(SIM2_SLOTID, eccVec), 0);
+        }
+        JudgeIsEmergencyPhoneNumber();
     }
-    JudgeIsEmergencyPhoneNumber();
 }
 
 HWTEST_F(Cs1Test, cellular_call_IsOperatorConfigEmergencyCallList_0001, Function | MediumTest | Level3)
@@ -264,27 +262,26 @@ HWTEST_F(Cs1Test, cellular_call_IsOperatorConfigEmergencyCallList_0001, Function
     auto telephonyService = iface_cast<CellularCallInterface>(operatorRemote);
     ASSERT_TRUE(telephonyService != nullptr);
 
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    OperatorConfig opc;
-    if (HasSimCard(SIM1_SLOTID)) {
-        DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorConfigs(SIM1_SLOTID, opc);
-        if (opc.stringArrayValue.find(KEY_EMERGENCY_CALL_STRING_ARRAY) != opc.stringArrayValue.end()) {
-            for (auto number : opc.stringArrayValue[KEY_EMERGENCY_CALL_STRING_ARRAY]) {
-                bool enabled = false;
-                int32_t errorCode = telephonyService->IsEmergencyPhoneNumber(SIM1_SLOTID, number, enabled);
-                EXPECT_EQ(TELEPHONY_SUCCESS, errorCode);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        OperatorConfig opc;
+        if (HasSimCard(SIM1_SLOTID)) {
+            DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorConfigs(SIM1_SLOTID, opc);
+            if (opc.stringArrayValue.find(KEY_EMERGENCY_CALL_STRING_ARRAY) != opc.stringArrayValue.end()) {
+                for (auto number : opc.stringArrayValue[KEY_EMERGENCY_CALL_STRING_ARRAY]) {
+                    bool enabled = false;
+                    int32_t errorCode = telephonyService->IsEmergencyPhoneNumber(SIM1_SLOTID, number, enabled);
+                    EXPECT_EQ(TELEPHONY_SUCCESS, errorCode);
+                }
             }
         }
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorConfigs(SIM2_SLOTID, opc);
-        if (opc.stringArrayValue.find(KEY_EMERGENCY_CALL_STRING_ARRAY) != opc.stringArrayValue.end()) {
-            for (auto number : opc.stringArrayValue[KEY_EMERGENCY_CALL_STRING_ARRAY]) {
-                bool enabled = false;
-                int32_t errorCode = telephonyService->IsEmergencyPhoneNumber(SIM2_SLOTID, number, enabled);
-                EXPECT_EQ(TELEPHONY_SUCCESS, errorCode);
+        if (HasSimCard(SIM2_SLOTID)) {
+            DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorConfigs(SIM2_SLOTID, opc);
+            if (opc.stringArrayValue.find(KEY_EMERGENCY_CALL_STRING_ARRAY) != opc.stringArrayValue.end()) {
+                for (auto number : opc.stringArrayValue[KEY_EMERGENCY_CALL_STRING_ARRAY]) {
+                    bool enabled = false;
+                    int32_t errorCode = telephonyService->IsEmergencyPhoneNumber(SIM2_SLOTID, number, enabled);
+                    EXPECT_EQ(TELEPHONY_SUCCESS, errorCode);
+                }
             }
         }
     }
@@ -297,9 +294,6 @@ HWTEST_F(Cs1Test, cellular_call_IsOperatorConfigEmergencyCallList_0001, Function
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0001, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*30#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -317,9 +311,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0001, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0002, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#30#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -337,9 +328,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0002, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0003, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#30#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -357,9 +345,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0003, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0004, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*31#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -377,9 +362,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0004, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0005, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#31#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -397,9 +379,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0005, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0006, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#31#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -417,9 +396,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0006, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0007, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*21#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -437,9 +413,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0007, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0008, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#21#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -457,9 +430,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0008, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0009, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#21#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -477,9 +447,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0009, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0010, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*33#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -497,9 +464,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0010, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0011, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#33#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -517,9 +481,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0011, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0012, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#33#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -537,9 +498,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0012, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0013, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*43#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -557,9 +515,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0013, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0014, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#43#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -577,9 +532,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0014, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0015, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#43#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -597,9 +549,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0015, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0016, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*04#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -617,9 +566,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0016, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0017, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*05#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -637,9 +583,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0017, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0018, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*042#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -657,9 +600,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0018, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0019, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*052#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -677,9 +617,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0019, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0020, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*4444#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -688,6 +625,7 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0020, Function | MediumTest | Level2)
         int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*4444#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
     }
+
 }
 
 /**
@@ -697,9 +635,6 @@ HWTEST_F(Cs1Test, cellular_call_DialCall_0020, Function | MediumTest | Level2)
  */
 HWTEST_F(Cs1Test, cellular_call_DialCall_0021, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(INVALID_SLOTID, PHONE_NUMBER);
         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
@@ -724,25 +659,24 @@ HWTEST_F(Cs1Test, cellular_call_HangUpCall_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(hangUpCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    CellularCallInfo hangUpCallInfo;
-    if (HasSimCard(SIM1_SLOTID)) {
-        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, hangUpCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
-        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
-        ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, hangUpCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
-        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
-        ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        CellularCallInfo hangUpCallInfo;
+        if (HasSimCard(SIM1_SLOTID)) {
+            int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, hangUpCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
+            EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
+            ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, hangUpCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
+            EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
+            ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+        }
     }
 }
 
@@ -754,28 +688,27 @@ HWTEST_F(Cs1Test, cellular_call_HangUpCall_0001, Function | MediumTest | Level2)
 HWTEST_F(Cs1Test, cellular_call_HangUpCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(hangUpCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo hangUpCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo hangUpCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(hangUpCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo hangUpCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo hangUpCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -793,9 +726,6 @@ HWTEST_F(Cs1Test, cellular_call_AnswerCall_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(answerCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo answerCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, answerCallInfo);
@@ -820,28 +750,27 @@ HWTEST_F(Cs1Test, cellular_call_AnswerCall_0001, Function | MediumTest | Level2)
 HWTEST_F(Cs1Test, cellular_call_AnswerCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(answerCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo answerCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->Answer(answerCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo answerCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->Answer(answerCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(answerCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo answerCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->Answer(answerCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo answerCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->Answer(answerCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -859,9 +788,6 @@ HWTEST_F(Cs1Test, cellular_call_RejectCall_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(rejectCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo rejectCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, rejectCallInfo);
@@ -886,28 +812,27 @@ HWTEST_F(Cs1Test, cellular_call_RejectCall_0001, Function | MediumTest | Level2)
 HWTEST_F(Cs1Test, cellular_call_RejectCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(rejectCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo rejectCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->Reject(rejectCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo rejectCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->Reject(rejectCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(rejectCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo rejectCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->Reject(rejectCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo rejectCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->Reject(rejectCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -925,9 +850,6 @@ HWTEST_F(Cs1Test, cellular_call_HoldCall_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(holdCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo holdCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, holdCallInfo);
@@ -952,28 +874,27 @@ HWTEST_F(Cs1Test, cellular_call_HoldCall_0001, Function | MediumTest | Level2)
 HWTEST_F(Cs1Test, cellular_call_HoldCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(holdCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo holdCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HoldCall(holdCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo holdCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HoldCall(holdCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(holdCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo holdCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HoldCall(holdCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo holdCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HoldCall(holdCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -991,9 +912,6 @@ HWTEST_F(Cs1Test, cellular_call_UnHoldCall_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(unHoldCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo unHoldCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, unHoldCallInfo);
@@ -1018,28 +936,27 @@ HWTEST_F(Cs1Test, cellular_call_UnHoldCall_0001, Function | MediumTest | Level2)
 HWTEST_F(Cs1Test, cellular_call_UnHoldCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(unHoldCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo unHoldCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->UnHoldCall(unHoldCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo unHoldCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->UnHoldCall(unHoldCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(unHoldCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo unHoldCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->UnHoldCall(unHoldCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo unHoldCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->UnHoldCall(unHoldCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -1057,9 +974,6 @@ HWTEST_F(Cs1Test, cellular_call_SwitchCall_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(switchCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo switchCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, switchCallInfo);
@@ -1084,28 +998,27 @@ HWTEST_F(Cs1Test, cellular_call_SwitchCall_0001, Function | MediumTest | Level2)
 HWTEST_F(Cs1Test, cellular_call_SwitchCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(switchCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo switchCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->SwitchCall(switchCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo switchCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->SwitchCall(switchCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(switchCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo switchCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->SwitchCall(switchCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo switchCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->SwitchCall(switchCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 } // namespace Telephony
diff --git a/test/unittest/cstest/cs2_test.cpp b/test/unittest/cstest/cs2_test.cpp
index 7d3d01a696d428b2bcf41e69d86c33bd9ef0ce69..e4d01939c055fb976cc13f8cca2c8e92852e01e8 100644
--- a/test/unittest/cstest/cs2_test.cpp
+++ b/test/unittest/cstest/cs2_test.cpp
@@ -149,9 +149,7 @@ HWTEST_F(Cs2Test, cellular_call_CombineConference_0001, Function | MediumTest |
     ASSERT_TRUE(combineRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo conferenceCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, conferenceCallInfo);
@@ -176,28 +174,27 @@ HWTEST_F(Cs2Test, cellular_call_CombineConference_0001, Function | MediumTest |
 HWTEST_F(Cs2Test, cellular_call_CombineConference_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(combineRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo conferenceCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->CombineConference(conferenceCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo conferenceCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->CombineConference(conferenceCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(combineRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo conferenceCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->CombineConference(conferenceCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo conferenceCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->CombineConference(conferenceCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -215,9 +212,7 @@ HWTEST_F(Cs2Test, cellular_call_SeparateConference_0001, Function | MediumTest |
     ASSERT_TRUE(separateRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -242,28 +237,27 @@ HWTEST_F(Cs2Test, cellular_call_SeparateConference_0001, Function | MediumTest |
 HWTEST_F(Cs2Test, cellular_call_SeparateConference_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(separateRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo separateCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->SeparateConference(separateCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo separateCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->SeparateConference(separateCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(separateRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo separateCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->SeparateConference(separateCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo separateCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->SeparateConference(separateCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -281,9 +275,7 @@ HWTEST_F(Cs2Test, cellular_call_KickOutFromConference_0001, Function | MediumTes
     ASSERT_TRUE(kickOutRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo kickOutCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, kickOutCallInfo);
@@ -308,28 +300,27 @@ HWTEST_F(Cs2Test, cellular_call_KickOutFromConference_0001, Function | MediumTes
 HWTEST_F(Cs2Test, cellular_call_KickOutFromConference_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(kickOutRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo kickOutCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->KickOutFromConference(kickOutCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo kickOutCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->KickOutFromConference(kickOutCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(kickOutRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo kickOutCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->KickOutFromConference(kickOutCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo kickOutCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->KickOutFromConference(kickOutCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -347,9 +338,7 @@ HWTEST_F(Cs2Test, cellular_call_HangUpAllConnection_0001, Function | MediumTest
     ASSERT_TRUE(hangUpAllConRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(hangUpAllConRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = telephonyService->HangUpAllConnection();
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -374,9 +363,7 @@ HWTEST_F(Cs2Test, cellular_call_StartDtmf_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(startDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -403,29 +390,28 @@ HWTEST_F(Cs2Test, cellular_call_StartDtmf_0001, Function | MediumTest | Level2)
 HWTEST_F(Cs2Test, cellular_call_StartDtmf_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(startDtmfRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    CellularCallInfo callInfo;
-    if (HasSimCard(SIM1_SLOTID)) {
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->StartDtmf(code, callInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->StartDtmf(code, callInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(startDtmfRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        CellularCallInfo callInfo;
+        if (HasSimCard(SIM1_SLOTID)) {
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->StartDtmf(code, callInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->StartDtmf(code, callInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -443,9 +429,7 @@ HWTEST_F(Cs2Test, cellular_call_StopDtmf_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(stopDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -470,28 +454,27 @@ HWTEST_F(Cs2Test, cellular_call_StopDtmf_0001, Function | MediumTest | Level2)
 HWTEST_F(Cs2Test, cellular_call_StopDtmf_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(stopDtmfRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo stopDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->StopDtmf(stopDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo stopDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->StopDtmf(stopDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(stopDtmfRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo stopDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->StopDtmf(stopDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo stopDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->StopDtmf(stopDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -509,9 +492,7 @@ HWTEST_F(Cs2Test, cellular_call_SendDtmf_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(sendDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo sendDtmfCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
@@ -538,30 +519,29 @@ HWTEST_F(Cs2Test, cellular_call_SendDtmf_0001, Function | MediumTest | Level2)
 HWTEST_F(Cs2Test, cellular_call_SendDtmf_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(sendDtmfRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo sendDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo sendDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(sendDtmfRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo sendDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo sendDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -579,9 +559,7 @@ HWTEST_F(Cs2Test, cellular_call_GetDomainPreferenceMode_0001, Function | MediumT
     ASSERT_TRUE(domainPrefModeRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(domainPrefModeRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = telephonyService->GetDomainPreferenceMode(INVALID_SLOTID);
         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
@@ -600,22 +578,21 @@ HWTEST_F(Cs2Test, cellular_call_GetDomainPreferenceMode_0001, Function | MediumT
 HWTEST_F(Cs2Test, cellular_call_GetDomainPreferenceMode_0002, Function | MediumTest | Level3)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto domainPrefModeRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(domainPrefModeRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(domainPrefModeRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        int32_t ret = telephonyService->GetDomainPreferenceMode(SIM1_SLOTID);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        int32_t ret = telephonyService->GetDomainPreferenceMode(SIM2_SLOTID);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto domainPrefModeRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(domainPrefModeRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(domainPrefModeRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            int32_t ret = telephonyService->GetDomainPreferenceMode(SIM1_SLOTID);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            int32_t ret = telephonyService->GetDomainPreferenceMode(SIM2_SLOTID);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+        }
     }
 }
 
@@ -633,9 +610,7 @@ HWTEST_F(Cs2Test, cellular_call_GetMute_0001, Function | MediumTest | Level3)
     ASSERT_TRUE(getMuteRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(getMuteRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = telephonyService->GetMute(INVALID_SLOTID);
         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
@@ -654,22 +629,21 @@ HWTEST_F(Cs2Test, cellular_call_GetMute_0001, Function | MediumTest | Level3)
 HWTEST_F(Cs2Test, cellular_call_GetMute_0002, Function | MediumTest | Level3)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto getMuteRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(getMuteRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(getMuteRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        int32_t ret = telephonyService->GetMute(SIM1_SLOTID);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        int32_t ret = telephonyService->GetMute(SIM2_SLOTID);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto getMuteRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(getMuteRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(getMuteRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            int32_t ret = telephonyService->GetMute(SIM1_SLOTID);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            int32_t ret = telephonyService->GetMute(SIM2_SLOTID);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+        }
     }
 }
 
@@ -684,47 +658,46 @@ HWTEST_F(Cs2Test, cellular_call_CsControl_0001, Function | MediumTest | Level3)
     ASSERT_TRUE(systemAbilityMgr != nullptr);
     auto csControlRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
     ASSERT_TRUE(csControlRemote != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto csControl = std::make_shared<CSControl>();
-    CellularCallInfo cellularCallInfo;
-    bool enabled = false;
-    EXPECT_EQ(InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
-    EXPECT_EQ(csControl->Dial(cellularCallInfo, enabled), CALL_ERR_GET_RADIO_STATE_FAILED);
-    EXPECT_EQ(InitCellularCallInfo(INVALID_SLOTID, "", cellularCallInfo), TELEPHONY_SUCCESS);
-    EXPECT_EQ(csControl->Dial(cellularCallInfo, enabled), CALL_ERR_PHONE_NUMBER_EMPTY);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
-        }
-        EXPECT_EQ(InitCellularCallInfo(slotId, "*30#", cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(csControl->DialCdma(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(csControl->DialGsm(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(InitCellularCallInfo(slotId, "#30#", cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(csControl->DialGsm(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(csControl->DialCdma(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto csControl = std::make_shared<CSControl>();
+        CellularCallInfo cellularCallInfo;
+        bool enabled = false;
+        EXPECT_EQ(InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
         EXPECT_EQ(csControl->Dial(cellularCallInfo, enabled), CALL_ERR_GET_RADIO_STATE_FAILED);
-        ASSERT_FALSE(csControl->CalculateInternationalRoaming(slotId));
-        EXPECT_NE(csControl->DialCdma(cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(csControl->DialGsm(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_NE(csControl->Answer(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_SECOND, cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_NE(csControl->Answer(cellularCallInfo), CALL_ERR_CALL_STATE);
-        EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_THIRD, cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_NE(csControl->Answer(cellularCallInfo), CALL_ERR_CALL_STATE);
-        EXPECT_NE(csControl->Reject(cellularCallInfo), CALL_ERR_CALL_STATE);
-        EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(csControl->SeparateConference(slotId, PHONE_NUMBER, 1), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(csControl->SeparateConference(slotId, "", 1), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_NE(csControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_DEFAULT), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(csControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE),
-            CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(
-            csControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ALL), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(csControl->HangUp(cellularCallInfo, static_cast<CallSupplementType>(INVALID_HANG_UP_TYPE)),
-            TELEPHONY_ERR_ARGUMENT_INVALID);
+        EXPECT_EQ(InitCellularCallInfo(INVALID_SLOTID, "", cellularCallInfo), TELEPHONY_SUCCESS);
+        EXPECT_EQ(csControl->Dial(cellularCallInfo, enabled), CALL_ERR_PHONE_NUMBER_EMPTY);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            EXPECT_EQ(InitCellularCallInfo(slotId, "*30#", cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(csControl->DialCdma(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(csControl->DialGsm(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(InitCellularCallInfo(slotId, "#30#", cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(csControl->DialGsm(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(csControl->DialCdma(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(csControl->Dial(cellularCallInfo, enabled), CALL_ERR_GET_RADIO_STATE_FAILED);
+            ASSERT_FALSE(csControl->CalculateInternationalRoaming(slotId));
+            EXPECT_NE(csControl->DialCdma(cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(csControl->DialGsm(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_NE(csControl->Answer(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_SECOND, cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_NE(csControl->Answer(cellularCallInfo), CALL_ERR_CALL_STATE);
+            EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_THIRD, cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_NE(csControl->Answer(cellularCallInfo), CALL_ERR_CALL_STATE);
+            EXPECT_NE(csControl->Reject(cellularCallInfo), CALL_ERR_CALL_STATE);
+            EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(csControl->SeparateConference(slotId, PHONE_NUMBER, 1), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(csControl->SeparateConference(slotId, "", 1), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_NE(csControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_DEFAULT), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(csControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE),
+                CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(
+                csControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ALL), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(csControl->HangUp(cellularCallInfo, static_cast<CallSupplementType>(INVALID_HANG_UP_TYPE)),
+                TELEPHONY_ERR_ARGUMENT_INVALID);
+        }
     }
 }
 
@@ -783,23 +756,21 @@ HWTEST_F(Cs2Test, cellular_call_CellularCallConnectionCS_0001, Function | Medium
     ASSERT_TRUE(systemAbilityMgr != nullptr);
     auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
     ASSERT_TRUE(remote != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            CellularCallConnectionCS csConnection;
+            EXPECT_EQ(csConnection.SendDtmfRequest(slotId, '1', 1), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(csConnection.StartDtmfRequest(slotId, '1', 1), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(csConnection.StopDtmfRequest(slotId, 1), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(csConnection.GetCsCallsDataRequest(slotId, 1), CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(csConnection.GetCallFailReasonRequest(slotId), CALL_ERR_RESOURCE_UNAVAILABLE);
+            MMICodeUtils utils;
+            ASSERT_FALSE(utils.IsNeedExecuteMmi("", false));
+            ASSERT_FALSE(utils.ExecuteMmiCode(slotId));
         }
-        CellularCallConnectionCS csConnection;
-        EXPECT_EQ(csConnection.SendDtmfRequest(slotId, '1', 1), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(csConnection.StartDtmfRequest(slotId, '1', 1), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(csConnection.StopDtmfRequest(slotId, 1), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(csConnection.GetCsCallsDataRequest(slotId, 1), CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(csConnection.GetCallFailReasonRequest(slotId), CALL_ERR_RESOURCE_UNAVAILABLE);
-        MMICodeUtils utils;
-        ASSERT_FALSE(utils.IsNeedExecuteMmi("", false));
-        ASSERT_FALSE(utils.ExecuteMmiCode(slotId));
     }
 }
 
@@ -814,46 +785,45 @@ HWTEST_F(Cs2Test, cellular_call_CellularCallRegister_0001, Function | MediumTest
     ASSERT_TRUE(systemAbilityMgr != nullptr);
     auto cellularCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
     ASSERT_TRUE(cellularCallRemote != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto callRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
+        ASSERT_TRUE(callRegister != nullptr);
+        CellularCallEventInfo callEvent;
+        callRegister->ReportEventResultInfo(callEvent);
+        CallWaitResponse waitResponse;
+        callRegister->ReportGetWaitingResult(waitResponse);
+        callRegister->ReportSetWaitingResult(ERROR_RESULT);
+        CallRestrictionResponse restrictionResponse;
+        callRegister->ReportGetRestrictionResult(restrictionResponse);
+        callRegister->ReportSetRestrictionResult(ERROR_RESULT);
+        callRegister->ReportSetBarringPasswordResult(ERROR_RESULT);
+        CallTransferResponse transferResponse;
+        callRegister->ReportGetTransferResult(transferResponse);
+        callRegister->ReportSetTransferResult(ERROR_RESULT);
+        ClipResponse clipResponse;
+        callRegister->ReportGetClipResult(clipResponse);
+        ClirResponse clirResponse;
+        callRegister->ReportGetClirResult(clirResponse);
+        callRegister->ReportSetClirResult(ERROR_RESULT);
+        callRegister->ReportCallRingBackResult(ERROR_RESULT);
+        DisconnectedDetails details;
+        callRegister->ReportCallFailReason(details);
+        MuteControlResponse muteResponse;
+        callRegister->ReportSetMuteResult(muteResponse);
+        callRegister->ReportGetMuteResult(muteResponse);
+        callRegister->ReportInviteToConferenceResult(ERROR_RESULT);
+        callRegister->ReportGetCallDataResult(ERROR_RESULT);
+        callRegister->ReportStartDtmfResult(ERROR_RESULT);
+        callRegister->ReportStopDtmfResult(ERROR_RESULT);
+        callRegister->ReportStartRttResult(ERROR_RESULT);
+        callRegister->ReportStopRttResult(ERROR_RESULT);
+        callRegister->ReportSendUssdResult(ERROR_RESULT);
+        SetEccListResponse eccListResponse;
+        callRegister->ReportSetEmergencyCallListResponse(eccListResponse);
+        MmiCodeInfo mmiInfo;
+        callRegister->ReportMmiCodeResult(mmiInfo);
+        ASSERT_FALSE(callRegister->IsCallManagerCallBackRegistered());
     }
-    auto callRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
-    ASSERT_TRUE(callRegister != nullptr);
-    CellularCallEventInfo callEvent;
-    callRegister->ReportEventResultInfo(callEvent);
-    CallWaitResponse waitResponse;
-    callRegister->ReportGetWaitingResult(waitResponse);
-    callRegister->ReportSetWaitingResult(ERROR_RESULT);
-    CallRestrictionResponse restrictionResponse;
-    callRegister->ReportGetRestrictionResult(restrictionResponse);
-    callRegister->ReportSetRestrictionResult(ERROR_RESULT);
-    callRegister->ReportSetBarringPasswordResult(ERROR_RESULT);
-    CallTransferResponse transferResponse;
-    callRegister->ReportGetTransferResult(transferResponse);
-    callRegister->ReportSetTransferResult(ERROR_RESULT);
-    ClipResponse clipResponse;
-    callRegister->ReportGetClipResult(clipResponse);
-    ClirResponse clirResponse;
-    callRegister->ReportGetClirResult(clirResponse);
-    callRegister->ReportSetClirResult(ERROR_RESULT);
-    callRegister->ReportCallRingBackResult(ERROR_RESULT);
-    DisconnectedDetails details;
-    callRegister->ReportCallFailReason(details);
-    MuteControlResponse muteResponse;
-    callRegister->ReportSetMuteResult(muteResponse);
-    callRegister->ReportGetMuteResult(muteResponse);
-    callRegister->ReportInviteToConferenceResult(ERROR_RESULT);
-    callRegister->ReportGetCallDataResult(ERROR_RESULT);
-    callRegister->ReportStartDtmfResult(ERROR_RESULT);
-    callRegister->ReportStopDtmfResult(ERROR_RESULT);
-    callRegister->ReportStartRttResult(ERROR_RESULT);
-    callRegister->ReportStopRttResult(ERROR_RESULT);
-    callRegister->ReportSendUssdResult(ERROR_RESULT);
-    SetEccListResponse eccListResponse;
-    callRegister->ReportSetEmergencyCallListResponse(eccListResponse);
-    MmiCodeInfo mmiInfo;
-    callRegister->ReportMmiCodeResult(mmiInfo);
-    ASSERT_FALSE(callRegister->IsCallManagerCallBackRegistered());
 }
 
 /**
@@ -885,34 +855,32 @@ HWTEST_F(Cs2Test, cellular_call_CellularCallRegister_0002, Function | MediumTest
  */
 HWTEST_F(Cs2Test, cellular_call_SupplementRequestCs_0001, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            SupplementRequestCs request;
+            std::string fac = "fac";
+            std::string pw = "test";
+            int32_t index = 1;
+            int32_t mode = 1;
+            int32_t classType = 1;
+            const char *oldPassword = "oldpwd";
+            const char *newPassword = "newpwd";
+            bool active = true;
+            CallTransferParam param;
+            EXPECT_NE(request.GetCallRestrictionRequest(slotId, fac, index), TELEPHONY_SUCCESS);
+            EXPECT_NE(request.SetCallRestrictionRequest(slotId, fac, mode, pw, index), TELEPHONY_SUCCESS);
+            EXPECT_NE(request.SetBarringPasswordRequest(slotId, fac, index, oldPassword, newPassword), TELEPHONY_SUCCESS);
+            EXPECT_NE(request.GetCallWaitingRequest(slotId, index), TELEPHONY_SUCCESS);
+            EXPECT_NE(request.SetCallWaitingRequest(slotId, active, classType, index), TELEPHONY_SUCCESS);
+            EXPECT_NE(request.GetClipRequest(slotId, index), TELEPHONY_SUCCESS);
+            EXPECT_NE(request.GetClirRequest(slotId, index), TELEPHONY_SUCCESS);
+            EXPECT_NE(request.SetClirRequest(slotId, mode, index), TELEPHONY_SUCCESS);
+            EXPECT_NE(request.GetCallTransferRequest(slotId, mode, index), TELEPHONY_SUCCESS);
+            EXPECT_NE(request.SetCallTransferRequest(slotId, param, index), TELEPHONY_SUCCESS);
         }
-        SupplementRequestCs request;
-        std::string fac = "fac";
-        std::string pw = "test";
-        int32_t index = 1;
-        int32_t mode = 1;
-        int32_t classType = 1;
-        const char *oldPassword = "oldpwd";
-        const char *newPassword = "newpwd";
-        bool active = true;
-        CallTransferParam param;
-        EXPECT_NE(request.GetCallRestrictionRequest(slotId, fac, index), TELEPHONY_SUCCESS);
-        EXPECT_NE(request.SetCallRestrictionRequest(slotId, fac, mode, pw, index), TELEPHONY_SUCCESS);
-        EXPECT_NE(request.SetBarringPasswordRequest(slotId, fac, index, oldPassword, newPassword), TELEPHONY_SUCCESS);
-        EXPECT_NE(request.GetCallWaitingRequest(slotId, index), TELEPHONY_SUCCESS);
-        EXPECT_NE(request.SetCallWaitingRequest(slotId, active, classType, index), TELEPHONY_SUCCESS);
-        EXPECT_NE(request.GetClipRequest(slotId, index), TELEPHONY_SUCCESS);
-        EXPECT_NE(request.GetClirRequest(slotId, index), TELEPHONY_SUCCESS);
-        EXPECT_NE(request.SetClirRequest(slotId, mode, index), TELEPHONY_SUCCESS);
-        EXPECT_NE(request.GetCallTransferRequest(slotId, mode, index), TELEPHONY_SUCCESS);
-        EXPECT_NE(request.SetCallTransferRequest(slotId, param, index), TELEPHONY_SUCCESS);
     }
 }
 
@@ -923,20 +891,18 @@ HWTEST_F(Cs2Test, cellular_call_SupplementRequestCs_0001, Function | MediumTest
  */
 HWTEST_F(Cs2Test, cellular_call_ConfigRequest_0001, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            ConfigRequest config;
+            int32_t mode = 1;
+            EXPECT_NE(config.SetDomainPreferenceModeRequest(slotId, mode), TELEPHONY_SUCCESS);
+            EXPECT_NE(config.GetDomainPreferenceModeRequest(slotId), TELEPHONY_SUCCESS);
+            EXPECT_NE(config.SetMuteRequest(slotId, mode), TELEPHONY_SUCCESS);
+            EXPECT_NE(config.GetMuteRequest(slotId), TELEPHONY_SUCCESS);
         }
-        ConfigRequest config;
-        int32_t mode = 1;
-        EXPECT_NE(config.SetDomainPreferenceModeRequest(slotId, mode), TELEPHONY_SUCCESS);
-        EXPECT_NE(config.GetDomainPreferenceModeRequest(slotId), TELEPHONY_SUCCESS);
-        EXPECT_NE(config.SetMuteRequest(slotId, mode), TELEPHONY_SUCCESS);
-        EXPECT_NE(config.GetMuteRequest(slotId), TELEPHONY_SUCCESS);
     }
 }
 
@@ -947,36 +913,34 @@ HWTEST_F(Cs2Test, cellular_call_ConfigRequest_0001, Function | MediumTest | Leve
  */
 HWTEST_F(Cs2Test, cellular_call_CellularCallSupplement_0001, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            MMIData mmiData;
+            CellularCallSupplement supplement;
+            mmiData.actionString = "";
+            supplement.AlterPinPassword(slotId, mmiData);
+            supplement.AlterPin2Password(slotId, mmiData);
+            supplement.UnlockPuk(slotId, mmiData);
+            supplement.UnlockPuk2(slotId, mmiData);
+            mmiData.actionString = "test";
+            mmiData.serviceInfoA = "infoA";
+            mmiData.serviceInfoB = "infoB";
+            mmiData.serviceInfoC = "infoC";
+            supplement.AlterPinPassword(slotId, mmiData);
+            supplement.AlterPin2Password(slotId, mmiData);
+            supplement.UnlockPuk(slotId, mmiData);
+            supplement.UnlockPuk2(slotId, mmiData);
+            mmiData.serviceInfoC = "infoB";
+            supplement.AlterPinPassword(slotId, mmiData);
+            supplement.AlterPin2Password(slotId, mmiData);
+            supplement.UnlockPuk(slotId, mmiData);
+            supplement.UnlockPuk2(slotId, mmiData);
+            ASSERT_FALSE(supplement.IsVaildPinOrPuk("B", "B"));
+            EXPECT_NE(supplement.SendUssd(slotId, "test"), TELEPHONY_SUCCESS);
         }
-        MMIData mmiData;
-        CellularCallSupplement supplement;
-        mmiData.actionString = "";
-        supplement.AlterPinPassword(slotId, mmiData);
-        supplement.AlterPin2Password(slotId, mmiData);
-        supplement.UnlockPuk(slotId, mmiData);
-        supplement.UnlockPuk2(slotId, mmiData);
-        mmiData.actionString = "test";
-        mmiData.serviceInfoA = "infoA";
-        mmiData.serviceInfoB = "infoB";
-        mmiData.serviceInfoC = "infoC";
-        supplement.AlterPinPassword(slotId, mmiData);
-        supplement.AlterPin2Password(slotId, mmiData);
-        supplement.UnlockPuk(slotId, mmiData);
-        supplement.UnlockPuk2(slotId, mmiData);
-        mmiData.serviceInfoC = "infoB";
-        supplement.AlterPinPassword(slotId, mmiData);
-        supplement.AlterPin2Password(slotId, mmiData);
-        supplement.UnlockPuk(slotId, mmiData);
-        supplement.UnlockPuk2(slotId, mmiData);
-        ASSERT_FALSE(supplement.IsVaildPinOrPuk("B", "B"));
-        EXPECT_NE(supplement.SendUssd(slotId, "test"), TELEPHONY_SUCCESS);
     }
 }
 
@@ -987,44 +951,42 @@ HWTEST_F(Cs2Test, cellular_call_CellularCallSupplement_0001, Function | MediumTe
  */
 HWTEST_F(Cs2Test, cellular_call_CellularCallSupplement_0002, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
-        }
-        CellularCallSupplement supplement;
-        supplement.ObtainBarringInstallation("33");
-        supplement.ObtainBarringInstallation("331");
-        supplement.ObtainBarringInstallation("332");
-        supplement.ObtainBarringInstallation("351");
-        supplement.ObtainBarringInstallation("35");
-        supplement.ObtainBarringInstallation("330");
-        supplement.ObtainBarringInstallation("333");
-        supplement.ObtainBarringInstallation("353");
-        supplement.ObtainBarringInstallation("1000");
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            CellularCallSupplement supplement;
+            supplement.ObtainBarringInstallation("33");
+            supplement.ObtainBarringInstallation("331");
+            supplement.ObtainBarringInstallation("332");
+            supplement.ObtainBarringInstallation("351");
+            supplement.ObtainBarringInstallation("35");
+            supplement.ObtainBarringInstallation("330");
+            supplement.ObtainBarringInstallation("333");
+            supplement.ObtainBarringInstallation("353");
+            supplement.ObtainBarringInstallation("1000");
 
-        EXPECT_NE(supplement.ObtainServiceCode("10"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("11"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("12"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("13"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("16"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("19"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("20"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("21"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("22"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("24"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("25"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainServiceCode("99"), TELEPHONY_SUCCESS);
-        EXPECT_EQ(supplement.ObtainServiceCode("100"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("10"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("11"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("12"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("13"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("16"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("19"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("20"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("21"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("22"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("24"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("25"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainServiceCode("99"), TELEPHONY_SUCCESS);
+            EXPECT_EQ(supplement.ObtainServiceCode("100"), TELEPHONY_SUCCESS);
 
-        EXPECT_EQ(supplement.ObtainCause("21"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainCause("61"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainCause("62"), TELEPHONY_SUCCESS);
-        EXPECT_NE(supplement.ObtainCause("67"), TELEPHONY_SUCCESS);
-        EXPECT_EQ(supplement.ObtainCause("99"), TELEPHONY_ERROR);
+            EXPECT_EQ(supplement.ObtainCause("21"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainCause("61"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainCause("62"), TELEPHONY_SUCCESS);
+            EXPECT_NE(supplement.ObtainCause("67"), TELEPHONY_SUCCESS);
+            EXPECT_EQ(supplement.ObtainCause("99"), TELEPHONY_ERROR);
+        }
     }
 }
 
@@ -1035,28 +997,26 @@ HWTEST_F(Cs2Test, cellular_call_CellularCallSupplement_0002, Function | MediumTe
  */
 HWTEST_F(Cs2Test, cellular_call_CellularCallSupplement_0003, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            CellularCallSupplement supplement;
+            std::string action = "*";
+            std::string number = "";
+            CallTransferSettingType type;
+            EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
+            EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), PHONE_NUMBER, type), TELEPHONY_SUCCESS);
+            action = "#";
+            EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
+            action = "**";
+            EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
+            action = "##";
+            EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
+            action = "*#";
+            EXPECT_NE(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
         }
-        CellularCallSupplement supplement;
-        std::string action = "*";
-        std::string number = "";
-        CallTransferSettingType type;
-        EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
-        EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), PHONE_NUMBER, type), TELEPHONY_SUCCESS);
-        action = "#";
-        EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
-        action = "**";
-        EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
-        action = "##";
-        EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
-        action = "*#";
-        EXPECT_NE(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
     }
 }
 
@@ -1067,47 +1027,45 @@ HWTEST_F(Cs2Test, cellular_call_CellularCallSupplement_0003, Function | MediumTe
  */
 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0001, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    EventFwk::MatchingSkills matchingSkills;
-    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
-    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
-    CellularCallHandler firstHandler { subscriberInfo };
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        EventFwk::MatchingSkills matchingSkills;
+        matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
+        EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
+        CellularCallHandler firstHandler { subscriberInfo };
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            firstHandler.SetSlotId(slotId);
+            auto event = AppExecFwk::InnerEvent::Get(0);
+            auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
+            rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
+            firstHandler.CellularCallIncomingStartTrace(static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING));
+            firstHandler.CellularCallIncomingFinishTrace(static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING));
+            firstHandler.GetCsCallsDataResponse(event);
+            firstHandler.GetCsCallsDataRequest(event);
+            firstHandler.GetMMIResponse(event);
+            auto ringbackResponse = std::make_shared<RingbackVoice>();
+            ringbackResponse->status = ERROR_RESULT;
+            auto ringbackEvent = AppExecFwk::InnerEvent::Get(0, ringbackResponse);
+            firstHandler.CallRingBackVoiceResponse(event);
+            firstHandler.CallRingBackVoiceResponse(ringbackEvent);
+            auto srvccStatus = std::make_shared<SrvccStatus>();
+            srvccStatus->status = SrvccState::SRVCC_NONE;
+            auto srvccEvent1 = AppExecFwk::InnerEvent::Get(0, srvccStatus);
+            firstHandler.UpdateSrvccStateReport(event);
+            firstHandler.UpdateSrvccStateReport(srvccEvent1);
+            srvccStatus->status = SrvccState::COMPLETED;
+            auto srvccEvent2 = AppExecFwk::InnerEvent::Get(0, srvccStatus);
+            firstHandler.UpdateSrvccStateReport(srvccEvent2);
+            firstHandler.UpdateRsrvccStateReport(event);
+            firstHandler.GetCallFailReasonResponse(event);
+            firstHandler.GetEmergencyCallListResponse(event);
+            firstHandler.ReportEccChanged(event);
+            firstHandler.SetEmergencyCallListResponse(event);
+            firstHandler.SendUssdResponse(event);
+            ASSERT_EQ(firstHandler.GetSlotId(), slotId);
         }
-        firstHandler.SetSlotId(slotId);
-        auto event = AppExecFwk::InnerEvent::Get(0);
-        auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
-        rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
-        firstHandler.CellularCallIncomingStartTrace(static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING));
-        firstHandler.CellularCallIncomingFinishTrace(static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING));
-        firstHandler.GetCsCallsDataResponse(event);
-        firstHandler.GetCsCallsDataRequest(event);
-        firstHandler.GetMMIResponse(event);
-        auto ringbackResponse = std::make_shared<RingbackVoice>();
-        ringbackResponse->status = ERROR_RESULT;
-        auto ringbackEvent = AppExecFwk::InnerEvent::Get(0, ringbackResponse);
-        firstHandler.CallRingBackVoiceResponse(event);
-        firstHandler.CallRingBackVoiceResponse(ringbackEvent);
-        auto srvccStatus = std::make_shared<SrvccStatus>();
-        srvccStatus->status = SrvccState::SRVCC_NONE;
-        auto srvccEvent1 = AppExecFwk::InnerEvent::Get(0, srvccStatus);
-        firstHandler.UpdateSrvccStateReport(event);
-        firstHandler.UpdateSrvccStateReport(srvccEvent1);
-        srvccStatus->status = SrvccState::COMPLETED;
-        auto srvccEvent2 = AppExecFwk::InnerEvent::Get(0, srvccStatus);
-        firstHandler.UpdateSrvccStateReport(srvccEvent2);
-        firstHandler.UpdateRsrvccStateReport(event);
-        firstHandler.GetCallFailReasonResponse(event);
-        firstHandler.GetEmergencyCallListResponse(event);
-        firstHandler.ReportEccChanged(event);
-        firstHandler.SetEmergencyCallListResponse(event);
-        firstHandler.SendUssdResponse(event);
-        ASSERT_EQ(firstHandler.GetSlotId(), slotId);
     }
 }
 
@@ -1118,56 +1076,54 @@ HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0001, Function | MediumTest
  */
 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0002, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    EventFwk::MatchingSkills matchingSkills;
-    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
-    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
-    CellularCallHandler secondHandler { subscriberInfo };
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
-        }
-        secondHandler.SetSlotId(slotId);
-        auto event = AppExecFwk::InnerEvent::Get(0);
-        auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
-        rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
-        secondHandler.CommonResultResponse(event);
-        auto rejectEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_REJECT_CALL, rilRadioResponse);
-        secondHandler.CommonResultResponse(rejectEvent);
-        auto supplementEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CALL_SUPPLEMENT, rilRadioResponse);
-        secondHandler.CommonResultResponse(supplementEvent);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        EventFwk::MatchingSkills matchingSkills;
+        matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
+        EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
+        CellularCallHandler secondHandler { subscriberInfo };
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            secondHandler.SetSlotId(slotId);
+            auto event = AppExecFwk::InnerEvent::Get(0);
+            auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
+            rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
+            secondHandler.CommonResultResponse(event);
+            auto rejectEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_REJECT_CALL, rilRadioResponse);
+            secondHandler.CommonResultResponse(rejectEvent);
+            auto supplementEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CALL_SUPPLEMENT, rilRadioResponse);
+            secondHandler.CommonResultResponse(supplementEvent);
 
-        rilRadioResponse->error = ErrType::NONE;
-        auto hangupConnectEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_HANGUP_CONNECT, rilRadioResponse);
-        secondHandler.CommonResultResponse(hangupConnectEvent);
-        auto acceptEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_ACCEPT_CALL, rilRadioResponse);
-        secondHandler.CommonResultResponse(acceptEvent);
-        auto splitNoErrorEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SPLIT_CALL, rilRadioResponse);
-        secondHandler.CommonResultResponse(splitNoErrorEvent);
+            rilRadioResponse->error = ErrType::NONE;
+            auto hangupConnectEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_HANGUP_CONNECT, rilRadioResponse);
+            secondHandler.CommonResultResponse(hangupConnectEvent);
+            auto acceptEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_ACCEPT_CALL, rilRadioResponse);
+            secondHandler.CommonResultResponse(acceptEvent);
+            auto splitNoErrorEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SPLIT_CALL, rilRadioResponse);
+            secondHandler.CommonResultResponse(splitNoErrorEvent);
 
-        auto ssResult = std::make_shared<SsBaseResult>();
-        ssResult->index = INVALID_INDEX;
-        ssResult->result = SUCCESS_RESULT;
-        auto errorEvent = AppExecFwk::InnerEvent::Get(0, ssResult);
-        secondHandler.SetCallRestrictionResponse(event);
-        secondHandler.SetCallRestrictionResponse(errorEvent);
-        secondHandler.SetBarringPasswordResponse(event);
-        secondHandler.SetCallTransferInfoResponse(event);
-        secondHandler.SetCallWaitingResponse(event);
-        secondHandler.SetClipResponse(event);
-        secondHandler.SetClirResponse(event);
-        secondHandler.SetColpResponse(event);
-        secondHandler.SetColrResponse(event);
+            auto ssResult = std::make_shared<SsBaseResult>();
+            ssResult->index = INVALID_INDEX;
+            ssResult->result = SUCCESS_RESULT;
+            auto errorEvent = AppExecFwk::InnerEvent::Get(0, ssResult);
+            secondHandler.SetCallRestrictionResponse(event);
+            secondHandler.SetCallRestrictionResponse(errorEvent);
+            secondHandler.SetBarringPasswordResponse(event);
+            secondHandler.SetCallTransferInfoResponse(event);
+            secondHandler.SetCallWaitingResponse(event);
+            secondHandler.SetClipResponse(event);
+            secondHandler.SetClirResponse(event);
+            secondHandler.SetColpResponse(event);
+            secondHandler.SetColrResponse(event);
 
-        auto responseEvent = AppExecFwk::InnerEvent::Get(0, rilRadioResponse);
-        secondHandler.SetMuteResponse(event);
-        secondHandler.SetMuteResponse(responseEvent);
-        secondHandler.GetMuteResponse(event);
-        secondHandler.GetMuteResponse(responseEvent);
-        ASSERT_EQ(secondHandler.GetSlotId(), slotId);
+            auto responseEvent = AppExecFwk::InnerEvent::Get(0, rilRadioResponse);
+            secondHandler.SetMuteResponse(event);
+            secondHandler.SetMuteResponse(responseEvent);
+            secondHandler.GetMuteResponse(event);
+            secondHandler.GetMuteResponse(responseEvent);
+            ASSERT_EQ(secondHandler.GetSlotId(), slotId);
+        }
     }
 }
 
@@ -1178,53 +1134,52 @@ HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0002, Function | MediumTest
  */
 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0003, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    EventFwk::MatchingSkills matchingSkills;
-    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
-    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
-    CellularCallHandler thirdhandler { subscriberInfo };
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
-        }
-        thirdhandler.SetSlotId(slotId);
-        auto event = AppExecFwk::InnerEvent::Get(0);
-        auto ussdNoticeResponse = std::make_shared<UssdNoticeInfo>();
-        ussdNoticeResponse->m = USSD_MODE_NOTIFY;
-        ussdNoticeResponse->str = "tdd test";
-        auto successEvent = AppExecFwk::InnerEvent::Get(0, ussdNoticeResponse);
-        thirdhandler.UssdNotifyResponse(event);
-        thirdhandler.UssdNotifyResponse(successEvent);
-        ussdNoticeResponse->str = "";
-        auto errorEvent = AppExecFwk::InnerEvent::Get(0, ussdNoticeResponse);
-        thirdhandler.UssdNotifyResponse(errorEvent);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        EventFwk::MatchingSkills matchingSkills;
+        matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
+        EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
+        CellularCallHandler thirdhandler { subscriberInfo };
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            thirdhandler.SetSlotId(slotId);
+            auto event = AppExecFwk::InnerEvent::Get(0);
+            auto ussdNoticeResponse = std::make_shared<UssdNoticeInfo>();
+            ussdNoticeResponse->m = USSD_MODE_NOTIFY;
+            ussdNoticeResponse->str = "tdd test";
+            auto successEvent = AppExecFwk::InnerEvent::Get(0, ussdNoticeResponse);
+            thirdhandler.UssdNotifyResponse(event);
+            thirdhandler.UssdNotifyResponse(successEvent);
+            ussdNoticeResponse->str = "";
+            auto errorEvent = AppExecFwk::InnerEvent::Get(0, ussdNoticeResponse);
+            thirdhandler.UssdNotifyResponse(errorEvent);
 
-        auto ssNoticeResponse = std::make_shared<SsNoticeInfo>();
-        ssNoticeResponse->result = ERROR_RESULT;
-        auto defaultEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
-        thirdhandler.SsNotifyResponse(event);
-        thirdhandler.SsNotifyResponse(defaultEvent);
-        ssNoticeResponse->requestType = SUCCESS_RESULT;
-        auto noticeErrorEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
-        thirdhandler.SsNotifyResponse(noticeErrorEvent);
-        ssNoticeResponse->result = SUCCESS_RESULT;
-        auto noticeDefaultEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
-        thirdhandler.SsNotifyResponse(noticeDefaultEvent);
-        ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_UNCONDITIONAL);
-        auto noticeUnconditinalEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
-        thirdhandler.SsNotifyResponse(noticeUnconditinalEvent);
-        ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_BUSY);
-        auto noticeBusyEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
-        thirdhandler.SsNotifyResponse(noticeBusyEvent);
-        ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NO_REPLY);
-        auto noticeNoReplyEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
-        thirdhandler.SsNotifyResponse(noticeNoReplyEvent);
-        ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NOT_REACHABLE);
-        auto noticeNotReachableEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
-        thirdhandler.SsNotifyResponse(noticeNotReachableEvent);
-        ASSERT_EQ(thirdhandler.GetSlotId(), slotId);
+            auto ssNoticeResponse = std::make_shared<SsNoticeInfo>();
+            ssNoticeResponse->result = ERROR_RESULT;
+            auto defaultEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
+            thirdhandler.SsNotifyResponse(event);
+            thirdhandler.SsNotifyResponse(defaultEvent);
+            ssNoticeResponse->requestType = SUCCESS_RESULT;
+            auto noticeErrorEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
+            thirdhandler.SsNotifyResponse(noticeErrorEvent);
+            ssNoticeResponse->result = SUCCESS_RESULT;
+            auto noticeDefaultEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
+            thirdhandler.SsNotifyResponse(noticeDefaultEvent);
+            ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_UNCONDITIONAL);
+            auto noticeUnconditinalEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
+            thirdhandler.SsNotifyResponse(noticeUnconditinalEvent);
+            ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_BUSY);
+            auto noticeBusyEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
+            thirdhandler.SsNotifyResponse(noticeBusyEvent);
+            ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NO_REPLY);
+            auto noticeNoReplyEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
+            thirdhandler.SsNotifyResponse(noticeNoReplyEvent);
+            ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NOT_REACHABLE);
+            auto noticeNotReachableEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
+            thirdhandler.SsNotifyResponse(noticeNotReachableEvent);
+            ASSERT_EQ(thirdhandler.GetSlotId(), slotId);
+        }
     }
 }
 
diff --git a/test/unittest/cstest/cs_calloperation_test.cpp b/test/unittest/cstest/cs_calloperation_test.cpp
index f01f15d91ab6904301894c0d9155917b1ca66c26..4549fb03495f31a7fb2fcdb0fcf5393a0433322a 100644
--- a/test/unittest/cstest/cs_calloperation_test.cpp
+++ b/test/unittest/cstest/cs_calloperation_test.cpp
@@ -137,9 +137,6 @@ void CsCallOperationTest::TearDown(void)
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0001, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*30#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -157,9 +154,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0001, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0002, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#30#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -177,9 +171,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0002, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0003, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#30#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -197,9 +188,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0003, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0004, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*31#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -217,9 +205,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0004, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0005, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#31#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -237,9 +222,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0005, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0006, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#31#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -257,9 +239,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0006, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0007, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*21#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -277,9 +256,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0007, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0008, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#21#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -297,9 +273,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0008, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0009, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#21#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -317,9 +290,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0009, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0010, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*33#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -337,9 +307,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0010, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0011, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#33#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -357,9 +324,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0011, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0012, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#33#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -377,9 +341,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0012, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0013, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*43#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -397,9 +358,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0013, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0014, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#43#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -417,9 +375,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0014, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0015, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#43#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -437,9 +392,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0015, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0016, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*04#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -457,9 +409,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0016, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0017, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*05#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -477,9 +426,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0017, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0018, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*042#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -497,9 +443,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0018, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0019, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*052#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -517,9 +460,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0019, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0020, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*4444#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -537,9 +477,6 @@ HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0020, Function | MediumTest
  */
 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0021, Function | MediumTest | Level2)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallByCs(INVALID_SLOTID, PHONE_NUMBER);
         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
@@ -564,9 +501,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_HangUpCall_0001, Function | MediumTe
     ASSERT_TRUE(hangUpCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     CellularCallInfo hangUpCallInfo;
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, hangUpCallInfo);
@@ -594,28 +529,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_HangUpCall_0001, Function | MediumTe
 HWTEST_F(CsCallOperationTest, cellular_call_HangUpCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(hangUpCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo hangUpCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo hangUpCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(hangUpCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo hangUpCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo hangUpCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -633,9 +567,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_AnswerCall_0001, Function | MediumTe
     ASSERT_TRUE(answerCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo answerCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, answerCallInfo);
@@ -660,28 +592,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_AnswerCall_0001, Function | MediumTe
 HWTEST_F(CsCallOperationTest, cellular_call_AnswerCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(answerCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo answerCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->Answer(answerCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo answerCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->Answer(answerCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(answerCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo answerCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->Answer(answerCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo answerCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->Answer(answerCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -699,9 +630,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_RejectCall_0001, Function | MediumTe
     ASSERT_TRUE(rejectCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo rejectCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, rejectCallInfo);
@@ -726,28 +655,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_RejectCall_0001, Function | MediumTe
 HWTEST_F(CsCallOperationTest, cellular_call_RejectCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(rejectCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo rejectCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->Reject(rejectCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo rejectCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->Reject(rejectCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(rejectCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo rejectCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->Reject(rejectCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo rejectCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->Reject(rejectCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -765,9 +693,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_HoldCall_0001, Function | MediumTest
     ASSERT_TRUE(holdCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo holdCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, holdCallInfo);
@@ -792,28 +718,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_HoldCall_0001, Function | MediumTest
 HWTEST_F(CsCallOperationTest, cellular_call_HoldCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(holdCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo holdCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HoldCall(holdCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo holdCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->HoldCall(holdCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(holdCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo holdCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HoldCall(holdCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo holdCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->HoldCall(holdCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -831,9 +756,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_UnHoldCall_0001, Function | MediumTe
     ASSERT_TRUE(unHoldCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo unHoldCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, unHoldCallInfo);
@@ -858,28 +781,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_UnHoldCall_0001, Function | MediumTe
 HWTEST_F(CsCallOperationTest, cellular_call_UnHoldCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(unHoldCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo unHoldCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->UnHoldCall(unHoldCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo unHoldCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->UnHoldCall(unHoldCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(unHoldCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo unHoldCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->UnHoldCall(unHoldCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo unHoldCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->UnHoldCall(unHoldCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -897,9 +819,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_SwitchCall_0001, Function | MediumTe
     ASSERT_TRUE(switchCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo switchCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, switchCallInfo);
@@ -924,28 +844,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_SwitchCall_0001, Function | MediumTe
 HWTEST_F(CsCallOperationTest, cellular_call_SwitchCall_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(switchCallRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo switchCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->SwitchCall(switchCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo switchCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->SwitchCall(switchCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(switchCallRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo switchCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->SwitchCall(switchCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo switchCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->SwitchCall(switchCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -963,9 +882,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_CombineConference_0001, Function | M
     ASSERT_TRUE(combineRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo conferenceCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, conferenceCallInfo);
@@ -990,28 +907,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_CombineConference_0001, Function | M
 HWTEST_F(CsCallOperationTest, cellular_call_CombineConference_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(combineRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo conferenceCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->CombineConference(conferenceCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo conferenceCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->CombineConference(conferenceCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(combineRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo conferenceCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->CombineConference(conferenceCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo conferenceCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->CombineConference(conferenceCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -1029,9 +945,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_SeparateConference_0001, Function |
     ASSERT_TRUE(separateRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -1056,28 +970,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_SeparateConference_0001, Function |
 HWTEST_F(CsCallOperationTest, cellular_call_SeparateConference_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(separateRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo separateCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->SeparateConference(separateCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo separateCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->SeparateConference(separateCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(separateRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo separateCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->SeparateConference(separateCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo separateCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->SeparateConference(separateCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -1095,9 +1008,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_KickOutFromConference_0001, Function
     ASSERT_TRUE(kickOutRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo kickOutCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, kickOutCallInfo);
@@ -1122,28 +1033,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_KickOutFromConference_0001, Function
 HWTEST_F(CsCallOperationTest, cellular_call_KickOutFromConference_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(kickOutRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo kickOutCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->KickOutFromConference(kickOutCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo kickOutCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->KickOutFromConference(kickOutCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(kickOutRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo kickOutCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->KickOutFromConference(kickOutCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo kickOutCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->KickOutFromConference(kickOutCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -1161,9 +1071,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_HangUpAllConnection_0001, Function |
     ASSERT_TRUE(hangUpAllConRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(hangUpAllConRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = telephonyService->HangUpAllConnection();
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -1188,9 +1096,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_StartDtmf_0001, Function | MediumTes
     ASSERT_TRUE(startDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -1217,29 +1123,28 @@ HWTEST_F(CsCallOperationTest, cellular_call_StartDtmf_0001, Function | MediumTes
 HWTEST_F(CsCallOperationTest, cellular_call_StartDtmf_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(startDtmfRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    CellularCallInfo callInfo;
-    if (HasSimCard(SIM1_SLOTID)) {
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->StartDtmf(code, callInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->StartDtmf(code, callInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(startDtmfRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        CellularCallInfo callInfo;
+        if (HasSimCard(SIM1_SLOTID)) {
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->StartDtmf(code, callInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->StartDtmf(code, callInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -1257,9 +1162,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_StopDtmf_0001, Function | MediumTest
     ASSERT_TRUE(stopDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -1284,28 +1187,27 @@ HWTEST_F(CsCallOperationTest, cellular_call_StopDtmf_0001, Function | MediumTest
 HWTEST_F(CsCallOperationTest, cellular_call_StopDtmf_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(stopDtmfRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo stopDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->StopDtmf(stopDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo stopDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->StopDtmf(stopDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(stopDtmfRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo stopDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->StopDtmf(stopDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo stopDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->StopDtmf(stopDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -1323,9 +1225,7 @@ HWTEST_F(CsCallOperationTest, cellular_call_SendDtmf_0001, Function | MediumTest
     ASSERT_TRUE(sendDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo sendDtmfCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
@@ -1352,30 +1252,29 @@ HWTEST_F(CsCallOperationTest, cellular_call_SendDtmf_0001, Function | MediumTest
 HWTEST_F(CsCallOperationTest, cellular_call_SendDtmf_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(sendDtmfRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo sendDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo sendDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(sendDtmfRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo sendDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo sendDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 } // namespace Telephony
diff --git a/test/unittest/imstest/ims1_test.cpp b/test/unittest/imstest/ims1_test.cpp
index 8ab35429831c94bad38967d1dd9dbc156ba21959..137f9ba640701f54cbcf4c32a76a43ced718375a 100644
--- a/test/unittest/imstest/ims1_test.cpp
+++ b/test/unittest/imstest/ims1_test.cpp
@@ -161,9 +161,6 @@ HWTEST_F(Ims1Test, cellular_call_ims_test_001, Function | MediumTest | Level0)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0001, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*30#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -181,10 +178,7 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0001, Function | MediumTest | Level2)
  */
 HWTEST_F(Ims1Test, cellular_call_DialCall_0002, Function | MediumTest | Level2)
 {
-    AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+    AccessToken token;     
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#30#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -202,10 +196,7 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0002, Function | MediumTest | Level2)
  */
 HWTEST_F(Ims1Test, cellular_call_DialCall_0003, Function | MediumTest | Level2)
 {
-    AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+    AccessToken token;   
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#30#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -223,10 +214,7 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0003, Function | MediumTest | Level2)
  */
 HWTEST_F(Ims1Test, cellular_call_DialCall_0004, Function | MediumTest | Level2)
 {
-    AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+    AccessToken token; 
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*31#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -245,9 +233,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0004, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0005, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#31#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -266,9 +251,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0005, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0006, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#31#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -286,10 +268,7 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0006, Function | MediumTest | Level2)
  */
 HWTEST_F(Ims1Test, cellular_call_DialCall_0007, Function | MediumTest | Level2)
 {
-    AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+    AccessToken token; 
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*21#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -308,9 +287,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0007, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0008, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#21#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -329,9 +305,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0008, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0009, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#21#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -350,9 +323,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0009, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0010, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*33#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -371,9 +341,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0010, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0011, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#33#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -392,9 +359,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0011, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0012, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#33#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -413,9 +377,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0012, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0013, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*43#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -434,9 +395,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0013, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0014, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#43#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -455,9 +413,6 @@ HWTEST_F(Ims1Test, cellular_call_DialCall_0014, Function | MediumTest | Level2)
 HWTEST_F(Ims1Test, cellular_call_DialCall_0015, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#43#");
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -486,9 +441,6 @@ HWTEST_F(Ims1Test, cellular_call_HangUpCall_0001, Function | MediumTest | Level2
     ASSERT_TRUE(hangUpCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -523,9 +475,6 @@ HWTEST_F(Ims1Test, cellular_call_AnswerCall_0001, Function | MediumTest | Level2
     ASSERT_TRUE(answerCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -556,9 +505,6 @@ HWTEST_F(Ims1Test, cellular_call_RejectCall_0001, Function | MediumTest | Level2
     ASSERT_TRUE(rejectCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -589,9 +535,6 @@ HWTEST_F(Ims1Test, cellular_call_HoldCall_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(holdCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -622,9 +565,6 @@ HWTEST_F(Ims1Test, cellular_call_UnHoldCall_0001, Function | MediumTest | Level2
     ASSERT_TRUE(unHoldCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -655,9 +595,6 @@ HWTEST_F(Ims1Test, cellular_call_SwitchCall_0001, Function | MediumTest | Level2
     ASSERT_TRUE(switchCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -688,9 +625,6 @@ HWTEST_F(Ims1Test, cellular_call_CombineConference_0001, Function | MediumTest |
     ASSERT_TRUE(combineRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -721,9 +655,6 @@ HWTEST_F(Ims1Test, cellular_call_SeparateConference_0001, Function | MediumTest
     ASSERT_TRUE(separateRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -754,9 +685,6 @@ HWTEST_F(Ims1Test, cellular_call_KickOutFromConference_0001, Function | MediumTe
     ASSERT_TRUE(kickOutRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -787,9 +715,6 @@ HWTEST_F(Ims1Test, cellular_call_StartDtmf_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(startDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -822,9 +747,6 @@ HWTEST_F(Ims1Test, cellular_call_StopDtmf_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(stopDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -855,9 +777,6 @@ HWTEST_F(Ims1Test, cellular_call_SendDtmf_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(sendDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -890,9 +809,6 @@ HWTEST_F(Ims1Test, cellular_call_CanSetCallTransferTime_0001, Function | MediumT
     ASSERT_TRUE(transferRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(transferRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
         bool result;
         int32_t ret = telephonyService->CanSetCallTransferTime(SIM1_SLOTID, result);
@@ -920,9 +836,6 @@ HWTEST_F(Ims1Test, cellular_call_SetVoNRState_0001, Function | MediumTest | Leve
     ASSERT_TRUE(setVoNRRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(setVoNRRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = telephonyService->SetVoNRState(SIM1_SLOTID, 1);
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
diff --git a/test/unittest/imstest/ims2_test.cpp b/test/unittest/imstest/ims2_test.cpp
index a4ccfdb23529ec1150c7da5f9c19c51485206331..ad24161b6cf67c2426a22336c4290fefef6ab1ab 100644
--- a/test/unittest/imstest/ims2_test.cpp
+++ b/test/unittest/imstest/ims2_test.cpp
@@ -142,22 +142,21 @@ void Ims2Test::TearDown(void)
 HWTEST_F(Ims2Test, cellular_call_SetVoNRState_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto setVoNRRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(setVoNRRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(setVoNRRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        int32_t ret = telephonyService->SetVoNRState(SIM1_SLOTID, 0);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        int32_t ret = telephonyService->SetVoNRState(SIM2_SLOTID, 0);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto setVoNRRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(setVoNRRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(setVoNRRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            int32_t ret = telephonyService->SetVoNRState(SIM1_SLOTID, 0);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            int32_t ret = telephonyService->SetVoNRState(SIM2_SLOTID, 0);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+        }
     }
 }
 
@@ -175,9 +174,6 @@ HWTEST_F(Ims2Test, cellular_call_GetVoNRState_0001, Function | MediumTest | Leve
     ASSERT_TRUE(getVoNRRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(getVoNRRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t result;
         int32_t ret = telephonyService->GetVoNRState(SIM1_SLOTID, result);
@@ -204,9 +200,6 @@ HWTEST_F(Ims2Test, cellular_call_StartRtt_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(startRttRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(startRttRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
         int32_t ret = telephonyService->StartRtt(SIM1_SLOTID, PHONE_NUMBER);
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -231,9 +224,6 @@ HWTEST_F(Ims2Test, cellular_call_StopRtt_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(stopRttRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(stopRttRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
         int32_t ret = telephonyService->StopRtt(SIM1_SLOTID);
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -258,9 +248,6 @@ HWTEST_F(Ims2Test, cellular_call_SetDomainPreferenceMode_0001, Function | Medium
     ASSERT_TRUE(domainPrefModeRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(domainPrefModeRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
         int32_t mode = -1;
         int32_t ret = telephonyService->SetDomainPreferenceMode(SIM1_SLOTID, mode);
@@ -287,9 +274,6 @@ HWTEST_F(Ims2Test, cellular_call_GetImsConfig_0001, Function | MediumTest | Leve
     ASSERT_TRUE(getImsConfigRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(getImsConfigRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
         ImsConfigItem mode = ITEM_IMS_SWITCH_STATUS;
         int32_t ret = telephonyService->GetImsConfig(SIM1_SLOTID, mode);
@@ -316,9 +300,6 @@ HWTEST_F(Ims2Test, cellular_call_GetImsFeatureValue_0001, Function | MediumTest
     ASSERT_TRUE(getImsFeatureRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(getImsFeatureRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
         FeatureType mode = TYPE_VOICE_OVER_LTE;
         int32_t ret = telephonyService->GetImsFeatureValue(SIM1_SLOTID, mode);
@@ -345,9 +326,6 @@ HWTEST_F(Ims2Test, cellular_call_SetMute_0001, Function | MediumTest | Level2)
     ASSERT_TRUE(setMuteRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(setMuteRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
         int32_t mode = 0;
         int32_t ret = telephonyService->SetMute(SIM1_SLOTID, mode);
@@ -374,9 +352,6 @@ HWTEST_F(Ims2Test, cellular_call_SetCallWaiting_0001, Function | MediumTest | Le
     ASSERT_TRUE(SetCWRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(SetCWRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
         bool act = true;
         int32_t ret = telephonyService->SetCallWaiting(SIM1_SLOTID, act);
@@ -403,9 +378,6 @@ HWTEST_F(Ims2Test, cellular_call_GetCallWaiting_0001, Function | MediumTest | Le
     ASSERT_TRUE(getCWRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(getCWRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
         int32_t ret = telephonyService->GetCallWaiting(SIM1_SLOTID);
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -430,9 +402,6 @@ HWTEST_F(Ims2Test, cellular_call_SetCallRestriction_0001, Function | MediumTest
     ASSERT_TRUE(setCRRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(setCRRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
         CallRestrictionInfo crInfo;
         int32_t ret = telephonyService->SetCallRestriction(SIM1_SLOTID, crInfo);
@@ -459,9 +428,6 @@ HWTEST_F(Ims2Test, cellular_call_GetCallRestriction_0001, Function | MediumTest
     ASSERT_TRUE(getCRRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(getCRRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
         CallRestrictionType facType = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
         int32_t ret = telephonyService->GetCallRestriction(SIM1_SLOTID, facType);
@@ -488,9 +454,6 @@ HWTEST_F(Ims2Test, cellular_call_SetCallTransferInfo_0001, Function | MediumTest
     ASSERT_TRUE(setTransferRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(setTransferRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
         CallTransferInfo ctInfo;
         int32_t ret = telephonyService->SetCallTransferInfo(SIM1_SLOTID, ctInfo);
@@ -517,9 +480,6 @@ HWTEST_F(Ims2Test, cellular_call_GetCallTransferInfo_0001, Function | MediumTest
     ASSERT_TRUE(getTransferRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(getTransferRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
         CallTransferType type = CallTransferType::TRANSFER_TYPE_UNCONDITIONAL;
         int32_t ret = telephonyService->GetCallTransferInfo(SIM1_SLOTID, type);
@@ -544,42 +504,41 @@ HWTEST_F(Ims2Test, cellular_call_ImsControl_0001, Function | MediumTest | Level3
     ASSERT_TRUE(systemAbilityMgr != nullptr);
     auto imsControlRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
     ASSERT_TRUE(imsControlRemote != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto imsControl = std::make_shared<IMSControl>();
-    CellularCallInfo cellularCallInfo;
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId) || !CanUseImsService(slotId, ImsServiceType::TYPE_VOICE)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto imsControl = std::make_shared<IMSControl>();
+        CellularCallInfo cellularCallInfo;
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId) || !CanUseImsService(slotId, ImsServiceType::TYPE_VOICE)) {
+                continue;
+            }
+            EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_NE(imsControl->Reject(cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
+            bool enabled = false;
+            EXPECT_EQ(imsControl->Dial(cellularCallInfo, enabled), CALL_ERR_GET_RADIO_STATE_FAILED);
+            CLIRMode mode = CLIRMode::DEFAULT;
+            EXPECT_EQ(imsControl->DialJudgment(slotId, PHONE_NUMBER_SECOND, mode, 0), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsControl->DialJudgment(slotId, PHONE_NUMBER_THIRD, mode, 0), TELEPHONY_SUCCESS);
+            EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_SECOND, cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_THIRD, cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_FOUR, cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_NE(imsControl->Reject(cellularCallInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsControl->HoldCall(slotId), TELEPHONY_SUCCESS);
+            std::vector<std::string> numberList;
+            EXPECT_EQ(imsControl->KickOutFromConference(slotId, PHONE_NUMBER, cellularCallInfo.index), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsControl->InviteToConference(slotId, numberList), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsControl->StartRtt(slotId, PHONE_NUMBER), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsControl->StopRtt(slotId), TELEPHONY_SUCCESS);
+            EXPECT_NE(imsControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_DEFAULT), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE),
+                CALL_ERR_RESOURCE_UNAVAILABLE);
+            EXPECT_EQ(imsControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ALL), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsControl->HangUp(cellularCallInfo, static_cast<CallSupplementType>(INVALID_HANG_UP_TYPE)),
+                TELEPHONY_ERR_ARGUMENT_INVALID);
         }
-        EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_NE(imsControl->Reject(cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
-        bool enabled = false;
-        EXPECT_EQ(imsControl->Dial(cellularCallInfo, enabled), CALL_ERR_GET_RADIO_STATE_FAILED);
-        CLIRMode mode = CLIRMode::DEFAULT;
-        EXPECT_EQ(imsControl->DialJudgment(slotId, PHONE_NUMBER_SECOND, mode, 0), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsControl->DialJudgment(slotId, PHONE_NUMBER_THIRD, mode, 0), TELEPHONY_SUCCESS);
-        EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_SECOND, cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_THIRD, cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_FOUR, cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_NE(imsControl->Reject(cellularCallInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsControl->HoldCall(slotId), TELEPHONY_SUCCESS);
-        std::vector<std::string> numberList;
-        EXPECT_EQ(imsControl->KickOutFromConference(slotId, PHONE_NUMBER, cellularCallInfo.index), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsControl->InviteToConference(slotId, numberList), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsControl->StartRtt(slotId, PHONE_NUMBER), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsControl->StopRtt(slotId), TELEPHONY_SUCCESS);
-        EXPECT_NE(imsControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_DEFAULT), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE),
-            CALL_ERR_RESOURCE_UNAVAILABLE);
-        EXPECT_EQ(imsControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ALL), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsControl->HangUp(cellularCallInfo, static_cast<CallSupplementType>(INVALID_HANG_UP_TYPE)),
-            TELEPHONY_ERR_ARGUMENT_INVALID);
     }
 }
 
@@ -646,26 +605,25 @@ HWTEST_F(Ims2Test, cellular_call_CellularCallConnectionIMS_0001, Function | Medi
     ASSERT_TRUE(systemAbilityMgr != nullptr);
     auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
     ASSERT_TRUE(remote != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId) || !CanUseImsService(slotId, ImsServiceType::TYPE_VOICE)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId) || !CanUseImsService(slotId, ImsServiceType::TYPE_VOICE)) {
+                continue;
+            }
+            CellularCallConnectionIMS imsConnection;
+            EXPECT_EQ(imsConnection.SendDtmfRequest(slotId, '1', 1), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsConnection.StartDtmfRequest(slotId, '1', 1), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsConnection.StopDtmfRequest(slotId, 1), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsConnection.GetImsCallsDataRequest(slotId, 1), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsConnection.GetCallFailReasonRequest(slotId), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsConnection.AnswerRequest(slotId, PHONE_NUMBER, 0, slotId), TELEPHONY_SUCCESS);
+            ImsDialInfoStruct imsDialInfo;
+            imsDialInfo.phoneNum = PHONE_NUMBER_SECOND;
+            EXPECT_EQ(imsConnection.DialRequest(slotId, imsDialInfo), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsConnection.HangUpRequest(slotId, PHONE_NUMBER_SECOND, slotId), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsConnection.StartRttRequest(slotId, PHONE_NUMBER_THIRD), TELEPHONY_SUCCESS);
+            EXPECT_EQ(imsConnection.StopRttRequest(slotId), TELEPHONY_SUCCESS);
         }
-        CellularCallConnectionIMS imsConnection;
-        EXPECT_EQ(imsConnection.SendDtmfRequest(slotId, '1', 1), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsConnection.StartDtmfRequest(slotId, '1', 1), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsConnection.StopDtmfRequest(slotId, 1), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsConnection.GetImsCallsDataRequest(slotId, 1), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsConnection.GetCallFailReasonRequest(slotId), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsConnection.AnswerRequest(slotId, PHONE_NUMBER, 0, slotId), TELEPHONY_SUCCESS);
-        ImsDialInfoStruct imsDialInfo;
-        imsDialInfo.phoneNum = PHONE_NUMBER_SECOND;
-        EXPECT_EQ(imsConnection.DialRequest(slotId, imsDialInfo), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsConnection.HangUpRequest(slotId, PHONE_NUMBER_SECOND, slotId), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsConnection.StartRttRequest(slotId, PHONE_NUMBER_THIRD), TELEPHONY_SUCCESS);
-        EXPECT_EQ(imsConnection.StopRttRequest(slotId), TELEPHONY_SUCCESS);
     }
 }
 
@@ -680,28 +638,27 @@ HWTEST_F(Ims2Test, cellular_call_CellularCallRegister_0001, Function | MediumTes
     ASSERT_TRUE(systemAbilityMgr != nullptr);
     auto registerRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
     ASSERT_TRUE(registerRemote != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto callRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
+        ASSERT_TRUE(callRegister != nullptr);
+        GetImsConfigResponse imsConfigResponse;
+        callRegister->ReportGetImsConfigResult(imsConfigResponse);
+        callRegister->ReportSetImsConfigResult(RESULT);
+        GetImsFeatureValueResponse imsFeatureValueResponse;
+        callRegister->ReportGetImsFeatureResult(imsFeatureValueResponse);
+        callRegister->ReportSetImsFeatureResult(RESULT);
+        ImsCallModeReceiveInfo callModeInfo;
+        callRegister->ReceiveUpdateCallMediaModeRequest(-1, callModeInfo);
+        callRegister->ReceiveUpdateCallMediaModeResponse(-1, callModeInfo);
+        ImsCallSessionEventInfo callSessionEventInfo;
+        callRegister->HandleCallSessionEventChanged(callSessionEventInfo);
+        ImsCallPeerDimensionsInfo callPeerDimensionsInfo;
+        callRegister->HandlePeerDimensionsChanged(callPeerDimensionsInfo);
+        ImsCallDataUsageInfo callDataUsageInfo;
+        callRegister->HandleCallDataUsageChanged(callDataUsageInfo);
+        CameraCapabilitiesInfo cameraCapabilitiesInfo;
+        callRegister->HandleCameraCapabilitiesChanged(cameraCapabilitiesInfo);
     }
-    auto callRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
-    ASSERT_TRUE(callRegister != nullptr);
-    GetImsConfigResponse imsConfigResponse;
-    callRegister->ReportGetImsConfigResult(imsConfigResponse);
-    callRegister->ReportSetImsConfigResult(RESULT);
-    GetImsFeatureValueResponse imsFeatureValueResponse;
-    callRegister->ReportGetImsFeatureResult(imsFeatureValueResponse);
-    callRegister->ReportSetImsFeatureResult(RESULT);
-    ImsCallModeReceiveInfo callModeInfo;
-    callRegister->ReceiveUpdateCallMediaModeRequest(-1, callModeInfo);
-    callRegister->ReceiveUpdateCallMediaModeResponse(-1, callModeInfo);
-    ImsCallSessionEventInfo callSessionEventInfo;
-    callRegister->HandleCallSessionEventChanged(callSessionEventInfo);
-    ImsCallPeerDimensionsInfo callPeerDimensionsInfo;
-    callRegister->HandlePeerDimensionsChanged(callPeerDimensionsInfo);
-    ImsCallDataUsageInfo callDataUsageInfo;
-    callRegister->HandleCallDataUsageChanged(callDataUsageInfo);
-    CameraCapabilitiesInfo cameraCapabilitiesInfo;
-    callRegister->HandleCameraCapabilitiesChanged(cameraCapabilitiesInfo);
 }
 
 /**
@@ -743,39 +700,37 @@ HWTEST_F(Ims2Test, cellular_call_CellularCallRegister_0002, Function | MediumTes
  */
 HWTEST_F(Ims2Test, cellular_call_CellularCallConfig_0001, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            CellularCallConfig cellularCallConfig;
+            ASSERT_TRUE(cellularCallConfig.GetImsSwitchOnByDefaultConfig(INVALID_SLOTID));
+            ASSERT_TRUE(cellularCallConfig.GetImsSwitchOnByDefaultConfig(slotId));
+            ASSERT_FALSE(cellularCallConfig.GethideImsSwitchConfig(INVALID_SLOTID));
+            ASSERT_FALSE(cellularCallConfig.GethideImsSwitchConfig(slotId));
+            ASSERT_FALSE(cellularCallConfig.GetvolteSupportedConfig(INVALID_SLOTID));
+            ASSERT_FALSE(cellularCallConfig.GetvolteSupportedConfig(slotId));
+            cellularCallConfig.GetNrModeSupportedListConfig(INVALID_SLOTID);
+            cellularCallConfig.GetNrModeSupportedListConfig(slotId);
+            ASSERT_FALSE(cellularCallConfig.GetVolteProvisioningSupportedConfig(INVALID_SLOTID));
+            ASSERT_FALSE(cellularCallConfig.GetVolteProvisioningSupportedConfig(slotId));
+            ASSERT_FALSE(cellularCallConfig.GetSsOverUtSupportedConfig(INVALID_SLOTID));
+            ASSERT_FALSE(cellularCallConfig.GetSsOverUtSupportedConfig(slotId));
+            ASSERT_FALSE(cellularCallConfig.GetImsGbaRequiredConfig(INVALID_SLOTID));
+            ASSERT_FALSE(cellularCallConfig.GetImsGbaRequiredConfig(slotId));
+            ASSERT_FALSE(cellularCallConfig.GetUtProvisioningSupportedConfig(INVALID_SLOTID));
+            ASSERT_FALSE(cellularCallConfig.GetUtProvisioningSupportedConfig(slotId));
+            ASSERT_TRUE(cellularCallConfig.GetImsPreferForEmergencyConfig(INVALID_SLOTID));
+            ASSERT_TRUE(cellularCallConfig.GetImsPreferForEmergencyConfig(slotId));
+            cellularCallConfig.GetCallWaitingServiceClassConfig(INVALID_SLOTID);
+            cellularCallConfig.GetCallWaitingServiceClassConfig(slotId);
+            cellularCallConfig.GetImsCallDisconnectResoninfoMappingConfig(INVALID_SLOTID);
+            cellularCallConfig.GetImsCallDisconnectResoninfoMappingConfig(slotId);
+            ASSERT_FALSE(cellularCallConfig.GetForceVolteSwitchOnConfig(INVALID_SLOTID));
+            ASSERT_FALSE(cellularCallConfig.GetForceVolteSwitchOnConfig(slotId));
         }
-        CellularCallConfig cellularCallConfig;
-        ASSERT_TRUE(cellularCallConfig.GetImsSwitchOnByDefaultConfig(INVALID_SLOTID));
-        ASSERT_TRUE(cellularCallConfig.GetImsSwitchOnByDefaultConfig(slotId));
-        ASSERT_FALSE(cellularCallConfig.GethideImsSwitchConfig(INVALID_SLOTID));
-        ASSERT_FALSE(cellularCallConfig.GethideImsSwitchConfig(slotId));
-        ASSERT_FALSE(cellularCallConfig.GetvolteSupportedConfig(INVALID_SLOTID));
-        ASSERT_FALSE(cellularCallConfig.GetvolteSupportedConfig(slotId));
-        cellularCallConfig.GetNrModeSupportedListConfig(INVALID_SLOTID);
-        cellularCallConfig.GetNrModeSupportedListConfig(slotId);
-        ASSERT_FALSE(cellularCallConfig.GetVolteProvisioningSupportedConfig(INVALID_SLOTID));
-        ASSERT_FALSE(cellularCallConfig.GetVolteProvisioningSupportedConfig(slotId));
-        ASSERT_FALSE(cellularCallConfig.GetSsOverUtSupportedConfig(INVALID_SLOTID));
-        ASSERT_FALSE(cellularCallConfig.GetSsOverUtSupportedConfig(slotId));
-        ASSERT_FALSE(cellularCallConfig.GetImsGbaRequiredConfig(INVALID_SLOTID));
-        ASSERT_FALSE(cellularCallConfig.GetImsGbaRequiredConfig(slotId));
-        ASSERT_FALSE(cellularCallConfig.GetUtProvisioningSupportedConfig(INVALID_SLOTID));
-        ASSERT_FALSE(cellularCallConfig.GetUtProvisioningSupportedConfig(slotId));
-        ASSERT_TRUE(cellularCallConfig.GetImsPreferForEmergencyConfig(INVALID_SLOTID));
-        ASSERT_TRUE(cellularCallConfig.GetImsPreferForEmergencyConfig(slotId));
-        cellularCallConfig.GetCallWaitingServiceClassConfig(INVALID_SLOTID);
-        cellularCallConfig.GetCallWaitingServiceClassConfig(slotId);
-        cellularCallConfig.GetImsCallDisconnectResoninfoMappingConfig(INVALID_SLOTID);
-        cellularCallConfig.GetImsCallDisconnectResoninfoMappingConfig(slotId);
-        ASSERT_FALSE(cellularCallConfig.GetForceVolteSwitchOnConfig(INVALID_SLOTID));
-        ASSERT_FALSE(cellularCallConfig.GetForceVolteSwitchOnConfig(slotId));
     }
 }
 
@@ -826,38 +781,37 @@ HWTEST_F(Ims2Test, cellular_call_CellularCallHandler_0001, Function | MediumTest
     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
     CellularCallHandler handler { subscriberInfo };
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
-        }
-        handler.SetSlotId(slotId);
-        auto event = AppExecFwk::InnerEvent::Get(0);
-        handler.GetImsCallsDataResponse(event);
-        handler.GetImsCallsDataRequest(event);
-        auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
-        rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
-        auto responseEvent = AppExecFwk::InnerEvent::Get(0, rilRadioResponse);
-        handler.SetDomainPreferenceModeResponse(responseEvent);
-        handler.GetDomainPreferenceModeResponse(event);
-        handler.SetDomainPreferenceModeResponse(event);
-        handler.SetVoNRSwitchStatusResponse(responseEvent);
-        handler.NvCfgFinishedIndication(responseEvent);
-        handler.GetImsCapabilities(slotId);
-        handler.GetImsCapResponse(responseEvent);
-        ASSERT_EQ(handler.GetSlotId(), slotId);
-        handler.OnRilAdapterHostDied(event);
-        auto serviceInstance = DelayedSingleton<CellularCallService>::GetInstance();
-        if (serviceInstance != nullptr) {
-            std::shared_ptr<CSControl> csControl;
-            serviceInstance->SetCsControl(slotId, csControl);
-            std::shared_ptr<IMSControl> imsControl;
-            serviceInstance->SetImsControl(slotId, imsControl);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            handler.SetSlotId(slotId);
+            auto event = AppExecFwk::InnerEvent::Get(0);
+            handler.GetImsCallsDataResponse(event);
+            handler.GetImsCallsDataRequest(event);
+            auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
+            rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
+            auto responseEvent = AppExecFwk::InnerEvent::Get(0, rilRadioResponse);
+            handler.SetDomainPreferenceModeResponse(responseEvent);
+            handler.GetDomainPreferenceModeResponse(event);
+            handler.SetDomainPreferenceModeResponse(event);
+            handler.SetVoNRSwitchStatusResponse(responseEvent);
+            handler.NvCfgFinishedIndication(responseEvent);
+            handler.GetImsCapabilities(slotId);
+            handler.GetImsCapResponse(responseEvent);
+            ASSERT_EQ(handler.GetSlotId(), slotId);
             handler.OnRilAdapterHostDied(event);
-            ASSERT_TRUE(serviceInstance->GetCsControl(slotId) == nullptr);
-            ASSERT_TRUE(serviceInstance->GetCsControl(slotId) == nullptr);
+            auto serviceInstance = DelayedSingleton<CellularCallService>::GetInstance();
+            if (serviceInstance != nullptr) {
+                std::shared_ptr<CSControl> csControl;
+                serviceInstance->SetCsControl(slotId, csControl);
+                std::shared_ptr<IMSControl> imsControl;
+                serviceInstance->SetImsControl(slotId, imsControl);
+                handler.OnRilAdapterHostDied(event);
+                ASSERT_TRUE(serviceInstance->GetCsControl(slotId) == nullptr);
+                ASSERT_TRUE(serviceInstance->GetCsControl(slotId) == nullptr);
+            }
         }
     }
 }
@@ -873,22 +827,21 @@ HWTEST_F(Ims2Test, cellular_call_CellularCallHandler_0002, Function | MediumTest
     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
     CellularCallHandler handler { subscriberInfo };
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            handler.SetSlotId(slotId);
+            auto event = AppExecFwk::InnerEvent::Get(0);
+            handler.ReceiveUpdateCallMediaModeRequest(event);
+            handler.ReceiveUpdateCallMediaModeResponse(event);
+            handler.HandleCallSessionEventChanged(event);
+            handler.HandlePeerDimensionsChanged(event);
+            handler.HandleCallDataUsageChanged(event);
+            handler.HandleCameraCapabilitiesChanged(event);
+            EXPECT_TRUE(event != nullptr);
         }
-        handler.SetSlotId(slotId);
-        auto event = AppExecFwk::InnerEvent::Get(0);
-        handler.ReceiveUpdateCallMediaModeRequest(event);
-        handler.ReceiveUpdateCallMediaModeResponse(event);
-        handler.HandleCallSessionEventChanged(event);
-        handler.HandlePeerDimensionsChanged(event);
-        handler.HandleCallDataUsageChanged(event);
-        handler.HandleCameraCapabilitiesChanged(event);
-        EXPECT_TRUE(event != nullptr);
     }
 }
 
diff --git a/test/unittest/imstest/ims_callback_stub_test.cpp b/test/unittest/imstest/ims_callback_stub_test.cpp
index 2d7328e7df9b3ec8c7aa1cbac032a36086eeaa7a..481ab1b3ec7347fa1247801001b8b7ae91042d91 100644
--- a/test/unittest/imstest/ims_callback_stub_test.cpp
+++ b/test/unittest/imstest/ims_callback_stub_test.cpp
@@ -139,50 +139,49 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0001, Function |
 {
     sptr<ImsCallCallbackStub> stub = (std::make_unique<ImsCallCallbackStub>()).release();
     ASSERT_TRUE(stub != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            RadioResponseInfo rilRadioResponse;
+            rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
+            MessageParcel answerData;
+            MessageParcel answerReply;
+            ASSERT_TRUE(answerData.WriteInt32(slotId));
+            ASSERT_TRUE(answerData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnAnswerResponseInner(answerData, answerReply), TELEPHONY_SUCCESS);
+
+            MessageParcel dialData;
+            MessageParcel dialReply;
+            ASSERT_TRUE(dialData.WriteInt32(slotId));
+            ASSERT_TRUE(dialData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnDialResponseInner(dialData, dialReply), TELEPHONY_SUCCESS);
+
+            MessageParcel imsCallsData;
+            MessageParcel imsCallsReply;
+            ASSERT_TRUE(imsCallsData.WriteInt32(slotId));
+            ASSERT_TRUE(imsCallsData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnGetImsCallsDataResponseInner(imsCallsData, imsCallsReply), TELEPHONY_SUCCESS);
+
+            MessageParcel hangupData;
+            MessageParcel hangupReply;
+            ASSERT_TRUE(hangupData.WriteInt32(slotId));
+            ASSERT_TRUE(hangupData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnHangUpResponseInner(hangupData, hangupReply), TELEPHONY_SUCCESS);
+
+            MessageParcel holdCallData;
+            MessageParcel holdCallReply;
+            ASSERT_TRUE(holdCallData.WriteInt32(slotId));
+            ASSERT_TRUE(holdCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnHoldCallResponseInner(holdCallData, holdCallReply), TELEPHONY_SUCCESS);
+
+            MessageParcel rejectData;
+            MessageParcel rejectReply;
+            ASSERT_TRUE(rejectData.WriteInt32(slotId));
+            ASSERT_TRUE(rejectData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnRejectResponseInner(rejectData, rejectReply), TELEPHONY_SUCCESS);
         }
-        RadioResponseInfo rilRadioResponse;
-        rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
-        MessageParcel answerData;
-        MessageParcel answerReply;
-        ASSERT_TRUE(answerData.WriteInt32(slotId));
-        ASSERT_TRUE(answerData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnAnswerResponseInner(answerData, answerReply), TELEPHONY_SUCCESS);
-
-        MessageParcel dialData;
-        MessageParcel dialReply;
-        ASSERT_TRUE(dialData.WriteInt32(slotId));
-        ASSERT_TRUE(dialData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnDialResponseInner(dialData, dialReply), TELEPHONY_SUCCESS);
-
-        MessageParcel imsCallsData;
-        MessageParcel imsCallsReply;
-        ASSERT_TRUE(imsCallsData.WriteInt32(slotId));
-        ASSERT_TRUE(imsCallsData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnGetImsCallsDataResponseInner(imsCallsData, imsCallsReply), TELEPHONY_SUCCESS);
-
-        MessageParcel hangupData;
-        MessageParcel hangupReply;
-        ASSERT_TRUE(hangupData.WriteInt32(slotId));
-        ASSERT_TRUE(hangupData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnHangUpResponseInner(hangupData, hangupReply), TELEPHONY_SUCCESS);
-
-        MessageParcel holdCallData;
-        MessageParcel holdCallReply;
-        ASSERT_TRUE(holdCallData.WriteInt32(slotId));
-        ASSERT_TRUE(holdCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnHoldCallResponseInner(holdCallData, holdCallReply), TELEPHONY_SUCCESS);
-
-        MessageParcel rejectData;
-        MessageParcel rejectReply;
-        ASSERT_TRUE(rejectData.WriteInt32(slotId));
-        ASSERT_TRUE(rejectData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnRejectResponseInner(rejectData, rejectReply), TELEPHONY_SUCCESS);
     }
 }
 
@@ -193,58 +192,57 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0001, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0002, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    sptr<ImsCallCallbackStub> stubTestTwo = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestTwo != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestTwo = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestTwo != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            RadioResponseInfo rilRadioResponse;
+            rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
+            MessageParcel sendDtmfData;
+            MessageParcel sendDtmfReply;
+            ASSERT_TRUE(sendDtmfData.WriteInt32(slotId));
+            ASSERT_TRUE(sendDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_GE(stubTestTwo->OnSendDtmfResponseInner(sendDtmfData, sendDtmfReply), TELEPHONY_SUCCESS);
+
+            MessageParcel setImsSwitchData;
+            MessageParcel setImsSwitchReply;
+            ASSERT_TRUE(setImsSwitchData.WriteInt32(slotId));
+            ASSERT_TRUE(setImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stubTestTwo->OnSetImsSwitchResponseInner(setImsSwitchData, setImsSwitchReply), TELEPHONY_SUCCESS);
+
+            MessageParcel startDtmfData;
+            MessageParcel startDtmfReply;
+            ASSERT_TRUE(startDtmfData.WriteInt32(slotId));
+            ASSERT_TRUE(startDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stubTestTwo->OnStartDtmfResponseInner(startDtmfData, startDtmfReply), TELEPHONY_SUCCESS);
+
+            MessageParcel stopDtmfData;
+            MessageParcel stopDtmfReply;
+            ASSERT_TRUE(stopDtmfData.WriteInt32(slotId));
+            ASSERT_TRUE(stopDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stubTestTwo->OnStopDtmfResponseInner(stopDtmfData, stopDtmfReply), TELEPHONY_SUCCESS);
+
+            MessageParcel switchCallData;
+            MessageParcel switchCallReply;
+            ASSERT_TRUE(switchCallData.WriteInt32(slotId));
+            ASSERT_TRUE(switchCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stubTestTwo->OnSwitchCallResponseInner(switchCallData, switchCallReply), TELEPHONY_SUCCESS);
+
+            MessageParcel unholdData;
+            MessageParcel unholdReply;
+            ASSERT_TRUE(unholdData.WriteInt32(slotId));
+            ASSERT_TRUE(unholdData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stubTestTwo->OnUnHoldCallResponseInner(unholdData, unholdReply), TELEPHONY_SUCCESS);
+
+            MessageParcel getImsSwitchData;
+            MessageParcel getImsSwitchReply;
+            ASSERT_TRUE(getImsSwitchData.WriteInt32(slotId));
+            ASSERT_TRUE(getImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stubTestTwo->OnGetImsSwitchResponseInner(getImsSwitchData, getImsSwitchReply), TELEPHONY_SUCCESS);
         }
-        RadioResponseInfo rilRadioResponse;
-        rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
-        MessageParcel sendDtmfData;
-        MessageParcel sendDtmfReply;
-        ASSERT_TRUE(sendDtmfData.WriteInt32(slotId));
-        ASSERT_TRUE(sendDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_GE(stubTestTwo->OnSendDtmfResponseInner(sendDtmfData, sendDtmfReply), TELEPHONY_SUCCESS);
-
-        MessageParcel setImsSwitchData;
-        MessageParcel setImsSwitchReply;
-        ASSERT_TRUE(setImsSwitchData.WriteInt32(slotId));
-        ASSERT_TRUE(setImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stubTestTwo->OnSetImsSwitchResponseInner(setImsSwitchData, setImsSwitchReply), TELEPHONY_SUCCESS);
-
-        MessageParcel startDtmfData;
-        MessageParcel startDtmfReply;
-        ASSERT_TRUE(startDtmfData.WriteInt32(slotId));
-        ASSERT_TRUE(startDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stubTestTwo->OnStartDtmfResponseInner(startDtmfData, startDtmfReply), TELEPHONY_SUCCESS);
-
-        MessageParcel stopDtmfData;
-        MessageParcel stopDtmfReply;
-        ASSERT_TRUE(stopDtmfData.WriteInt32(slotId));
-        ASSERT_TRUE(stopDtmfData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stubTestTwo->OnStopDtmfResponseInner(stopDtmfData, stopDtmfReply), TELEPHONY_SUCCESS);
-
-        MessageParcel switchCallData;
-        MessageParcel switchCallReply;
-        ASSERT_TRUE(switchCallData.WriteInt32(slotId));
-        ASSERT_TRUE(switchCallData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stubTestTwo->OnSwitchCallResponseInner(switchCallData, switchCallReply), TELEPHONY_SUCCESS);
-
-        MessageParcel unholdData;
-        MessageParcel unholdReply;
-        ASSERT_TRUE(unholdData.WriteInt32(slotId));
-        ASSERT_TRUE(unholdData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stubTestTwo->OnUnHoldCallResponseInner(unholdData, unholdReply), TELEPHONY_SUCCESS);
-
-        MessageParcel getImsSwitchData;
-        MessageParcel getImsSwitchReply;
-        ASSERT_TRUE(getImsSwitchData.WriteInt32(slotId));
-        ASSERT_TRUE(getImsSwitchData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stubTestTwo->OnGetImsSwitchResponseInner(getImsSwitchData, getImsSwitchReply), TELEPHONY_SUCCESS);
     }
 }
 
@@ -255,41 +253,39 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0002, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0003, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    sptr<ImsCallCallbackStub> stubTestThree = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestThree != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestThree = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestThree != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            MessageParcel data;
+            MessageParcel reply;
+            ASSERT_TRUE(data.WriteInt32(slotId));
+            ASSERT_NE(stubTestThree->OnAnswerResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnCallRingBackReportInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnDialResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnHangUpResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnRejectResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnSendDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnSetImsSwitchResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnStartDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnStopDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnSwitchCallResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnUnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnSetMuteResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnCombineConferenceResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnInviteToConferenceResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeRequestInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeResponseInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnCallSessionEventChangedInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnPeerDimensionsChangedInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnCallDataUsageChangedInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnCameraCapabilitiesChangedInner(data, reply), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestThree->OnGetImsCapResponseInner(data, reply), TELEPHONY_SUCCESS);
         }
-        MessageParcel data;
-        MessageParcel reply;
-        ASSERT_TRUE(data.WriteInt32(slotId));
-        ASSERT_NE(stubTestThree->OnAnswerResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnCallRingBackReportInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnDialResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnHangUpResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnRejectResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnSendDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnSetImsSwitchResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnStartDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnStopDtmfResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnSwitchCallResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnUnHoldCallResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnSetMuteResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnCombineConferenceResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnInviteToConferenceResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeRequestInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnReceiveUpdateCallMediaModeResponseInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnCallSessionEventChangedInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnPeerDimensionsChangedInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnCallDataUsageChangedInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnCameraCapabilitiesChangedInner(data, reply), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestThree->OnGetImsCapResponseInner(data, reply), TELEPHONY_SUCCESS);
     }
 }
 
@@ -300,52 +296,51 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0003, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0004, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    sptr<ImsCallCallbackStub> stubTestFour = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestFour != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestFour = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestFour != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            SsBaseResult normalResult;
+            normalResult.index = DEFAULT_INDEX;
+            MessageParcel crData;
+            MessageParcel crReply;
+            ASSERT_TRUE(crData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFour->OnSetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
+            MessageParcel ctData;
+            MessageParcel ctReply;
+            ASSERT_TRUE(ctData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(ctData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFour->OnSetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
+            MessageParcel cwData;
+            MessageParcel cwReply;
+            ASSERT_TRUE(cwData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(cwData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFour->OnSetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
+            MessageParcel clipData;
+            MessageParcel clipReply;
+            ASSERT_TRUE(clipData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(clipData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFour->OnSetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
+            MessageParcel clirData;
+            MessageParcel clirReply;
+            ASSERT_TRUE(clirData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(clirData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFour->OnSetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
+            MessageParcel colpData;
+            MessageParcel colpReply;
+            ASSERT_TRUE(colpData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(colpData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFour->OnSetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
+            MessageParcel colrData;
+            MessageParcel colrReply;
+            ASSERT_TRUE(colrData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(colrData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFour->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
         }
-        SsBaseResult normalResult;
-        normalResult.index = DEFAULT_INDEX;
-        MessageParcel crData;
-        MessageParcel crReply;
-        ASSERT_TRUE(crData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFour->OnSetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
-        MessageParcel ctData;
-        MessageParcel ctReply;
-        ASSERT_TRUE(ctData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(ctData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFour->OnSetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
-        MessageParcel cwData;
-        MessageParcel cwReply;
-        ASSERT_TRUE(cwData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(cwData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFour->OnSetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
-        MessageParcel clipData;
-        MessageParcel clipReply;
-        ASSERT_TRUE(clipData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(clipData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFour->OnSetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
-        MessageParcel clirData;
-        MessageParcel clirReply;
-        ASSERT_TRUE(clirData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(clirData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFour->OnSetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
-        MessageParcel colpData;
-        MessageParcel colpReply;
-        ASSERT_TRUE(colpData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(colpData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFour->OnSetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
-        MessageParcel colrData;
-        MessageParcel colrReply;
-        ASSERT_TRUE(colrData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(colrData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFour->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
     }
 }
 
@@ -356,52 +351,51 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0004, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0005, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    sptr<ImsCallCallbackStub> stubTestFive = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestFive != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestFive = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestFive != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            SsBaseResult normalResult;
+            normalResult.index = INVALID_INDEX;
+            MessageParcel crData;
+            MessageParcel crReply;
+            ASSERT_TRUE(crData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFive->OnSetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
+            MessageParcel ctData;
+            MessageParcel ctReply;
+            ASSERT_TRUE(ctData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(ctData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFive->OnSetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
+            MessageParcel cwData;
+            MessageParcel cwReply;
+            ASSERT_TRUE(cwData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(cwData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFive->OnSetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
+            MessageParcel clipData;
+            MessageParcel clipReply;
+            ASSERT_TRUE(clipData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(clipData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFive->OnSetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
+            MessageParcel clirData;
+            MessageParcel clirReply;
+            ASSERT_TRUE(clirData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(clirData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFive->OnSetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
+            MessageParcel colpData;
+            MessageParcel colpReply;
+            ASSERT_TRUE(colpData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(colpData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFive->OnSetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
+            MessageParcel colrData;
+            MessageParcel colrReply;
+            ASSERT_TRUE(colrData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(colrData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestFive->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
         }
-        SsBaseResult normalResult;
-        normalResult.index = INVALID_INDEX;
-        MessageParcel crData;
-        MessageParcel crReply;
-        ASSERT_TRUE(crData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(crData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFive->OnSetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
-        MessageParcel ctData;
-        MessageParcel ctReply;
-        ASSERT_TRUE(ctData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(ctData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFive->OnSetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
-        MessageParcel cwData;
-        MessageParcel cwReply;
-        ASSERT_TRUE(cwData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(cwData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFive->OnSetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
-        MessageParcel clipData;
-        MessageParcel clipReply;
-        ASSERT_TRUE(clipData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(clipData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFive->OnSetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
-        MessageParcel clirData;
-        MessageParcel clirReply;
-        ASSERT_TRUE(clirData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(clirData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFive->OnSetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
-        MessageParcel colpData;
-        MessageParcel colpReply;
-        ASSERT_TRUE(colpData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(colpData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFive->OnSetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
-        MessageParcel colrData;
-        MessageParcel colrReply;
-        ASSERT_TRUE(colrData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(colrData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestFive->OnSetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
     }
 }
 
@@ -414,39 +408,38 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0006, Function |
 {
     sptr<ImsCallCallbackStub> stubTestSix = (std::make_unique<ImsCallCallbackStub>()).release();
     ASSERT_TRUE(stubTestSix != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            SsBaseResult ssBaseResult;
+            ssBaseResult.index = DEFAULT_INDEX;
+            ssBaseResult.result = IMS_ERROR_UT_CS_FALLBACK;
+            ASSERT_NE(stubTestSix->SetCallRestrictionResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestSix->SetCallTransferResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestSix->SetCallWaitingResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
+            ASSERT_NE(stubTestSix->SetClirResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
+            MessageParcel muteData;
+            MessageParcel muteReply;
+            MuteControlResponse muteResponse;
+            ASSERT_TRUE(muteData.WriteInt32(slotId));
+            ASSERT_TRUE(muteData.WriteRawData((const void *)&muteResponse, sizeof(MuteControlResponse)));
+            ASSERT_EQ(stubTestSix->OnSetMuteResponseInner(muteData, muteReply), TELEPHONY_SUCCESS);
+            MessageParcel ringData;
+            MessageParcel ringReply;
+            RingbackVoice ringback;
+            ASSERT_TRUE(ringData.WriteInt32(slotId));
+            ASSERT_TRUE(ringData.WriteRawData((const void *)&ringback, sizeof(RingbackVoice)));
+            ASSERT_EQ(stubTestSix->OnCallRingBackReportInner(ringData, ringReply), TELEPHONY_SUCCESS);
+            MessageParcel failData;
+            MessageParcel failReply;
+            DisconnectedDetails details;
+            ASSERT_TRUE(failData.WriteInt32(slotId));
+            ASSERT_TRUE(failData.WriteInt32(static_cast<int32_t>(details.reason)));
+            ASSERT_TRUE(failData.WriteString(details.message));
+            ASSERT_EQ(stubTestSix->OnLastCallFailReasonResponseInner(failData, failReply), TELEPHONY_SUCCESS);
         }
-        SsBaseResult ssBaseResult;
-        ssBaseResult.index = DEFAULT_INDEX;
-        ssBaseResult.result = IMS_ERROR_UT_CS_FALLBACK;
-        ASSERT_NE(stubTestSix->SetCallRestrictionResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestSix->SetCallTransferResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestSix->SetCallWaitingResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
-        ASSERT_NE(stubTestSix->SetClirResponse(slotId, ssBaseResult), TELEPHONY_SUCCESS);
-        MessageParcel muteData;
-        MessageParcel muteReply;
-        MuteControlResponse muteResponse;
-        ASSERT_TRUE(muteData.WriteInt32(slotId));
-        ASSERT_TRUE(muteData.WriteRawData((const void *)&muteResponse, sizeof(MuteControlResponse)));
-        ASSERT_EQ(stubTestSix->OnSetMuteResponseInner(muteData, muteReply), TELEPHONY_SUCCESS);
-        MessageParcel ringData;
-        MessageParcel ringReply;
-        RingbackVoice ringback;
-        ASSERT_TRUE(ringData.WriteInt32(slotId));
-        ASSERT_TRUE(ringData.WriteRawData((const void *)&ringback, sizeof(RingbackVoice)));
-        ASSERT_EQ(stubTestSix->OnCallRingBackReportInner(ringData, ringReply), TELEPHONY_SUCCESS);
-        MessageParcel failData;
-        MessageParcel failReply;
-        DisconnectedDetails details;
-        ASSERT_TRUE(failData.WriteInt32(slotId));
-        ASSERT_TRUE(failData.WriteInt32(static_cast<int32_t>(details.reason)));
-        ASSERT_TRUE(failData.WriteString(details.message));
-        ASSERT_EQ(stubTestSix->OnLastCallFailReasonResponseInner(failData, failReply), TELEPHONY_SUCCESS);
     }
 }
 
@@ -457,48 +450,47 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0006, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0007, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    sptr<ImsCallCallbackStub> stubTestSeven = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestSeven != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestSeven = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestSeven != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            CallRestrictionResult crResult;
+            crResult.result.index = INVALID_INDEX;
+            MessageParcel crErrorData;
+            MessageParcel crErrorReply;
+            ASSERT_TRUE(crErrorData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsResult(crErrorData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crErrorData, crErrorReply), TELEPHONY_SUCCESS);
+
+            crResult.result.index = DEFAULT_INDEX;
+            MessageParcel crData;
+            MessageParcel crReply;
+            ASSERT_TRUE(crData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsResult(crData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
+            crResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
+            ASSERT_NE(stubTestSeven->GetCallRestrictionResponse(slotId, crResult), TELEPHONY_SUCCESS);
+
+            CallForwardQueryInfoList callList;
+            callList.result.index = INVALID_INDEX;
+            MessageParcel ctErrorData;
+            MessageParcel ctErrorReply;
+            ASSERT_TRUE(ctErrorData.WriteInt32(slotId));
+            ASSERT_EQ(WriteCallForwardResult(ctErrorData, callList), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctErrorData, ctErrorReply), TELEPHONY_SUCCESS);
+
+            callList.result.index = DEFAULT_INDEX;
+            MessageParcel ctData;
+            MessageParcel ctReply;
+            ASSERT_TRUE(ctData.WriteInt32(slotId));
+            ASSERT_EQ(WriteCallForwardResult(ctData, callList), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
+            callList.result.result = IMS_ERROR_UT_CS_FALLBACK;
+            ASSERT_NE(stubTestSeven->GetCallTransferResponse(slotId, callList), TELEPHONY_SUCCESS);
         }
-        CallRestrictionResult crResult;
-        crResult.result.index = INVALID_INDEX;
-        MessageParcel crErrorData;
-        MessageParcel crErrorReply;
-        ASSERT_TRUE(crErrorData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsResult(crErrorData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crErrorData, crErrorReply), TELEPHONY_SUCCESS);
-
-        crResult.result.index = DEFAULT_INDEX;
-        MessageParcel crData;
-        MessageParcel crReply;
-        ASSERT_TRUE(crData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsResult(crData, crResult.result, crResult.status, crResult.classCw), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestSeven->OnGetCallRestrictionResponseInner(crData, crReply), TELEPHONY_SUCCESS);
-        crResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
-        ASSERT_NE(stubTestSeven->GetCallRestrictionResponse(slotId, crResult), TELEPHONY_SUCCESS);
-
-        CallForwardQueryInfoList callList;
-        callList.result.index = INVALID_INDEX;
-        MessageParcel ctErrorData;
-        MessageParcel ctErrorReply;
-        ASSERT_TRUE(ctErrorData.WriteInt32(slotId));
-        ASSERT_EQ(WriteCallForwardResult(ctErrorData, callList), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctErrorData, ctErrorReply), TELEPHONY_SUCCESS);
-
-        callList.result.index = DEFAULT_INDEX;
-        MessageParcel ctData;
-        MessageParcel ctReply;
-        ASSERT_TRUE(ctData.WriteInt32(slotId));
-        ASSERT_EQ(WriteCallForwardResult(ctData, callList), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestSeven->OnGetCallTransferResponseInner(ctData, ctReply), TELEPHONY_SUCCESS);
-        callList.result.result = IMS_ERROR_UT_CS_FALLBACK;
-        ASSERT_NE(stubTestSeven->GetCallTransferResponse(slotId, callList), TELEPHONY_SUCCESS);
     }
 }
 
@@ -509,50 +501,49 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0007, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0008, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    sptr<ImsCallCallbackStub> stubTestEigth = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestEigth != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestEigth = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestEigth != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            CallWaitResult cwResult;
+            cwResult.result.index = INVALID_INDEX;
+            MessageParcel cwErrorData;
+            MessageParcel cwErrorReply;
+            ASSERT_TRUE(cwErrorData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsResult(cwErrorData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwErrorData, cwErrorReply), TELEPHONY_SUCCESS);
+
+            cwResult.result.index = DEFAULT_INDEX;
+            MessageParcel cwData;
+            MessageParcel cwReply;
+            ASSERT_TRUE(cwData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsResult(cwData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
+            cwResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
+            ASSERT_NE(stubTestEigth->GetCallWaitingResponse(slotId, cwResult), TELEPHONY_SUCCESS);
+
+            GetClipResult clipResult;
+            clipResult.result.index = INVALID_INDEX;
+            MessageParcel clipErrorData;
+            MessageParcel clipErrorReply;
+            ASSERT_TRUE(clipErrorData.WriteInt32(slotId));
+            ASSERT_EQ(
+                WriteSsResult(clipErrorData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipErrorData, clipErrorReply), TELEPHONY_SUCCESS);
+
+            clipResult.result.index = DEFAULT_INDEX;
+            MessageParcel clipData;
+            MessageParcel clipReply;
+            ASSERT_TRUE(clipData.WriteInt32(slotId));
+            ASSERT_EQ(
+                WriteSsResult(clipData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
+            clipResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
+            ASSERT_NE(stubTestEigth->GetClipResponse(slotId, clipResult), TELEPHONY_SUCCESS);
         }
-        CallWaitResult cwResult;
-        cwResult.result.index = INVALID_INDEX;
-        MessageParcel cwErrorData;
-        MessageParcel cwErrorReply;
-        ASSERT_TRUE(cwErrorData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsResult(cwErrorData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwErrorData, cwErrorReply), TELEPHONY_SUCCESS);
-
-        cwResult.result.index = DEFAULT_INDEX;
-        MessageParcel cwData;
-        MessageParcel cwReply;
-        ASSERT_TRUE(cwData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsResult(cwData, cwResult.result, cwResult.status, cwResult.classCw), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestEigth->OnGetCallWaitingResponseInner(cwData, cwReply), TELEPHONY_SUCCESS);
-        cwResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
-        ASSERT_NE(stubTestEigth->GetCallWaitingResponse(slotId, cwResult), TELEPHONY_SUCCESS);
-
-        GetClipResult clipResult;
-        clipResult.result.index = INVALID_INDEX;
-        MessageParcel clipErrorData;
-        MessageParcel clipErrorReply;
-        ASSERT_TRUE(clipErrorData.WriteInt32(slotId));
-        ASSERT_EQ(
-            WriteSsResult(clipErrorData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipErrorData, clipErrorReply), TELEPHONY_SUCCESS);
-
-        clipResult.result.index = DEFAULT_INDEX;
-        MessageParcel clipData;
-        MessageParcel clipReply;
-        ASSERT_TRUE(clipData.WriteInt32(slotId));
-        ASSERT_EQ(
-            WriteSsResult(clipData, clipResult.result, clipResult.action, clipResult.clipStat), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestEigth->OnGetClipResponseInner(clipData, clipReply), TELEPHONY_SUCCESS);
-        clipResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
-        ASSERT_NE(stubTestEigth->GetClipResponse(slotId, clipResult), TELEPHONY_SUCCESS);
     }
 }
 
@@ -563,50 +554,49 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0008, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0009, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    sptr<ImsCallCallbackStub> stubTestNight = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestNight != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestNight = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestNight != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            GetClirResult clirResult;
+            clirResult.result.index = INVALID_INDEX;
+            MessageParcel clirErrorData;
+            MessageParcel clirErrorReply;
+            ASSERT_TRUE(clirErrorData.WriteInt32(slotId));
+            ASSERT_EQ(
+                WriteSsResult(clirErrorData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirErrorData, clirErrorReply), TELEPHONY_SUCCESS);
+
+            clirResult.result.index = DEFAULT_INDEX;
+            MessageParcel clirData;
+            MessageParcel clirReply;
+            ASSERT_TRUE(clirData.WriteInt32(slotId));
+            ASSERT_EQ(
+                WriteSsResult(clirData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
+            clirResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
+            ASSERT_NE(stubTestNight->GetClirResponse(slotId, clirResult), TELEPHONY_SUCCESS);
+
+            GetColpResult colpResult;
+            colpResult.result.index = INVALID_INDEX;
+            MessageParcel colpErrorData;
+            MessageParcel colpErrorReply;
+            ASSERT_TRUE(colpErrorData.WriteInt32(slotId));
+            ASSERT_EQ(
+                WriteSsResult(colpErrorData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpErrorData, colpErrorReply), TELEPHONY_SUCCESS);
+
+            colpResult.result.index = DEFAULT_INDEX;
+            MessageParcel colpData;
+            MessageParcel colpReply;
+            ASSERT_TRUE(colpData.WriteInt32(slotId));
+            ASSERT_EQ(
+                WriteSsResult(colpData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
         }
-        GetClirResult clirResult;
-        clirResult.result.index = INVALID_INDEX;
-        MessageParcel clirErrorData;
-        MessageParcel clirErrorReply;
-        ASSERT_TRUE(clirErrorData.WriteInt32(slotId));
-        ASSERT_EQ(
-            WriteSsResult(clirErrorData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirErrorData, clirErrorReply), TELEPHONY_SUCCESS);
-
-        clirResult.result.index = DEFAULT_INDEX;
-        MessageParcel clirData;
-        MessageParcel clirReply;
-        ASSERT_TRUE(clirData.WriteInt32(slotId));
-        ASSERT_EQ(
-            WriteSsResult(clirData, clirResult.result, clirResult.action, clirResult.clirStat), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestNight->OnGetClirResponseInner(clirData, clirReply), TELEPHONY_SUCCESS);
-        clirResult.result.result = IMS_ERROR_UT_CS_FALLBACK;
-        ASSERT_NE(stubTestNight->GetClirResponse(slotId, clirResult), TELEPHONY_SUCCESS);
-
-        GetColpResult colpResult;
-        colpResult.result.index = INVALID_INDEX;
-        MessageParcel colpErrorData;
-        MessageParcel colpErrorReply;
-        ASSERT_TRUE(colpErrorData.WriteInt32(slotId));
-        ASSERT_EQ(
-            WriteSsResult(colpErrorData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpErrorData, colpErrorReply), TELEPHONY_SUCCESS);
-
-        colpResult.result.index = DEFAULT_INDEX;
-        MessageParcel colpData;
-        MessageParcel colpReply;
-        ASSERT_TRUE(colpData.WriteInt32(slotId));
-        ASSERT_EQ(
-            WriteSsResult(colpData, colpResult.result, colpResult.action, colpResult.colpStat), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestNight->OnGetColpResponseInner(colpData, colpReply), TELEPHONY_SUCCESS);
     }
 }
 
@@ -617,52 +607,50 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0009, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0010, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-
-    sptr<ImsCallCallbackStub> stubTestTen = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestTen != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestTen = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestTen != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            GetColrResult colrResult;
+            colrResult.result.index = INVALID_INDEX;
+            MessageParcel colrErrorData;
+            MessageParcel colrErrorReply;
+            ASSERT_TRUE(colrErrorData.WriteInt32(slotId));
+            ASSERT_EQ(
+                WriteSsResult(colrErrorData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrErrorData, colrErrorReply), TELEPHONY_SUCCESS);
+
+            colrResult.result.index = DEFAULT_INDEX;
+            MessageParcel colrData;
+            MessageParcel colrReply;
+            ASSERT_TRUE(colrData.WriteInt32(slotId));
+            ASSERT_EQ(
+                WriteSsResult(colrData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS);
+            ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
+
+            SsBaseResult normalResult;
+            normalResult.index = DEFAULT_INDEX;
+            MessageParcel ctErrorData;
+            MessageParcel ctReply;
+            ASSERT_TRUE(ctErrorData.WriteInt32(slotId));
+            ASSERT_EQ(WriteSsBaseResult(ctErrorData, normalResult), TELEPHONY_SUCCESS);
+            ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
+            ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
+            ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
+            ASSERT_NE(stubTestTen->OnGetCallTransferResponseInner(ctErrorData, ctReply), TELEPHONY_SUCCESS);
+
+            MessageParcel icErrorData;
+            MessageParcel icReply;
+            ASSERT_TRUE(icErrorData.WriteInt32(slotId));
+            ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
+            ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
+            ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
+            ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
+            ASSERT_NE(stubTestTen->OnGetImsCallsDataResponseInner(icErrorData, icReply), TELEPHONY_SUCCESS);
         }
-        GetColrResult colrResult;
-        colrResult.result.index = INVALID_INDEX;
-        MessageParcel colrErrorData;
-        MessageParcel colrErrorReply;
-        ASSERT_TRUE(colrErrorData.WriteInt32(slotId));
-        ASSERT_EQ(
-            WriteSsResult(colrErrorData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrErrorData, colrErrorReply), TELEPHONY_SUCCESS);
-
-        colrResult.result.index = DEFAULT_INDEX;
-        MessageParcel colrData;
-        MessageParcel colrReply;
-        ASSERT_TRUE(colrData.WriteInt32(slotId));
-        ASSERT_EQ(
-            WriteSsResult(colrData, colrResult.result, colrResult.action, colrResult.colrStat), TELEPHONY_SUCCESS);
-        ASSERT_EQ(stubTestTen->OnGetColrResponseInner(colrData, colrReply), TELEPHONY_SUCCESS);
-
-        SsBaseResult normalResult;
-        normalResult.index = DEFAULT_INDEX;
-        MessageParcel ctErrorData;
-        MessageParcel ctReply;
-        ASSERT_TRUE(ctErrorData.WriteInt32(slotId));
-        ASSERT_EQ(WriteSsBaseResult(ctErrorData, normalResult), TELEPHONY_SUCCESS);
-        ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
-        ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
-        ASSERT_TRUE(ctErrorData.WriteInt32(INVALID_INDEX));
-        ASSERT_NE(stubTestTen->OnGetCallTransferResponseInner(ctErrorData, ctReply), TELEPHONY_SUCCESS);
-
-        MessageParcel icErrorData;
-        MessageParcel icReply;
-        ASSERT_TRUE(icErrorData.WriteInt32(slotId));
-        ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
-        ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
-        ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
-        ASSERT_TRUE(icErrorData.WriteInt32(INVALID_INDEX));
-        ASSERT_NE(stubTestTen->OnGetImsCallsDataResponseInner(icErrorData, icReply), TELEPHONY_SUCCESS);
     }
 }
 
@@ -673,42 +661,41 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0010, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0011, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestEleven != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestEleven != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            MessageParcel callModeReceiveRequestData;
+            MessageParcel callModeReceiveRequestReply;
+            ImsCallModeReceiveInfo callModeReceiveRequesInfo;
+            callModeReceiveRequesInfo.callIndex = DEFAULT_INDEX;
+            ASSERT_TRUE(callModeReceiveRequestData.WriteInt32(slotId));
+            ASSERT_TRUE(callModeReceiveRequestData.WriteRawData(
+                (const void *)&callModeReceiveRequesInfo, sizeof(ImsCallModeReceiveInfo)));
+            ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeRequestInner(
+                callModeReceiveRequestData, callModeReceiveRequestReply), TELEPHONY_SUCCESS);
+            MessageParcel callModeReceiveResponseData;
+            MessageParcel callModeReceiveResponseReply;
+            ImsCallModeReceiveInfo callModeReceiveResponseInfo;
+            callModeReceiveResponseInfo.callIndex = DEFAULT_INDEX;
+            ASSERT_TRUE(callModeReceiveResponseData.WriteInt32(slotId));
+            ASSERT_TRUE(callModeReceiveResponseData.WriteRawData(
+                (const void *)&callModeReceiveResponseInfo, sizeof(ImsCallModeReceiveInfo)));
+            ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeResponseInner(
+                callModeReceiveResponseData, callModeReceiveResponseReply), TELEPHONY_SUCCESS);
+            MessageParcel callSessionEventInfoData;
+            MessageParcel callSessionEventInfoReply;
+            ImsCallSessionEventInfo callSessionEventInfo;
+            callSessionEventInfo.callIndex = DEFAULT_INDEX;
+            ASSERT_TRUE(callSessionEventInfoData.WriteInt32(slotId));
+            ASSERT_TRUE(callSessionEventInfoData.WriteRawData(
+                (const void *)&callSessionEventInfo, sizeof(ImsCallSessionEventInfo)));
+            ASSERT_EQ(stubTestEleven->OnCallSessionEventChangedInner(
+                callSessionEventInfoData, callSessionEventInfoReply), TELEPHONY_SUCCESS);
         }
-        MessageParcel callModeReceiveRequestData;
-        MessageParcel callModeReceiveRequestReply;
-        ImsCallModeReceiveInfo callModeReceiveRequesInfo;
-        callModeReceiveRequesInfo.callIndex = DEFAULT_INDEX;
-        ASSERT_TRUE(callModeReceiveRequestData.WriteInt32(slotId));
-        ASSERT_TRUE(callModeReceiveRequestData.WriteRawData(
-            (const void *)&callModeReceiveRequesInfo, sizeof(ImsCallModeReceiveInfo)));
-        ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeRequestInner(
-            callModeReceiveRequestData, callModeReceiveRequestReply), TELEPHONY_SUCCESS);
-        MessageParcel callModeReceiveResponseData;
-        MessageParcel callModeReceiveResponseReply;
-        ImsCallModeReceiveInfo callModeReceiveResponseInfo;
-        callModeReceiveResponseInfo.callIndex = DEFAULT_INDEX;
-        ASSERT_TRUE(callModeReceiveResponseData.WriteInt32(slotId));
-        ASSERT_TRUE(callModeReceiveResponseData.WriteRawData(
-            (const void *)&callModeReceiveResponseInfo, sizeof(ImsCallModeReceiveInfo)));
-        ASSERT_EQ(stubTestEleven->OnReceiveUpdateCallMediaModeResponseInner(
-            callModeReceiveResponseData, callModeReceiveResponseReply), TELEPHONY_SUCCESS);
-        MessageParcel callSessionEventInfoData;
-        MessageParcel callSessionEventInfoReply;
-        ImsCallSessionEventInfo callSessionEventInfo;
-        callSessionEventInfo.callIndex = DEFAULT_INDEX;
-        ASSERT_TRUE(callSessionEventInfoData.WriteInt32(slotId));
-        ASSERT_TRUE(callSessionEventInfoData.WriteRawData(
-            (const void *)&callSessionEventInfo, sizeof(ImsCallSessionEventInfo)));
-        ASSERT_EQ(stubTestEleven->OnCallSessionEventChangedInner(
-            callSessionEventInfoData, callSessionEventInfoReply), TELEPHONY_SUCCESS);
     }
 }
 
@@ -719,42 +706,41 @@ HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0011, Function |
  */
 HWTEST_F(ImsCallbackStubTest, cellular_call_ImsCallCallbackStub_0012, Function | MediumTest | Level3)
 {
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release();
-    ASSERT_TRUE(stubTestEleven != nullptr);
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        sptr<ImsCallCallbackStub> stubTestEleven = (std::make_unique<ImsCallCallbackStub>()).release();
+        ASSERT_TRUE(stubTestEleven != nullptr);
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            MessageParcel callPeerDimensionsInfoData;
+            MessageParcel callPeerDimensionsInfoReply;
+            ImsCallPeerDimensionsInfo callPeerDimensionsInfo;
+            callPeerDimensionsInfo.callIndex = DEFAULT_INDEX;
+            ASSERT_TRUE(callPeerDimensionsInfoData.WriteInt32(slotId));
+            ASSERT_TRUE(callPeerDimensionsInfoData.WriteRawData(
+                (const void *)&callPeerDimensionsInfo, sizeof(ImsCallPeerDimensionsInfo)));
+            ASSERT_EQ(stubTestEleven->OnPeerDimensionsChangedInner(
+                callPeerDimensionsInfoData, callPeerDimensionsInfoReply), TELEPHONY_SUCCESS);
+            MessageParcel callDataUsageInfoData;
+            MessageParcel callDataUsageInfoReply;
+            ImsCallDataUsageInfo callDataUsageInfo;
+            callDataUsageInfo.callIndex = DEFAULT_INDEX;
+            ASSERT_TRUE(callDataUsageInfoData.WriteInt32(slotId));
+            ASSERT_TRUE(callDataUsageInfoData.WriteRawData(
+                (const void *)&callDataUsageInfo, sizeof(ImsCallDataUsageInfo)));
+            ASSERT_EQ(stubTestEleven->OnCallDataUsageChangedInner(
+                callDataUsageInfoData, callDataUsageInfoReply), TELEPHONY_SUCCESS);
+            MessageParcel cameraCapabilitiesInfoData;
+            MessageParcel cameraCapabilitiesInfoReply;
+            CameraCapabilitiesInfo cameraCapabilitiesInfo;
+            cameraCapabilitiesInfo.callIndex = DEFAULT_INDEX;
+            ASSERT_TRUE(cameraCapabilitiesInfoData.WriteInt32(slotId));
+            ASSERT_TRUE(cameraCapabilitiesInfoData.WriteRawData(
+                (const void *)&cameraCapabilitiesInfo, sizeof(CameraCapabilitiesInfo)));
+            ASSERT_EQ(stubTestEleven->OnCameraCapabilitiesChangedInner(
+                cameraCapabilitiesInfoData, cameraCapabilitiesInfoReply), TELEPHONY_SUCCESS);
         }
-        MessageParcel callPeerDimensionsInfoData;
-        MessageParcel callPeerDimensionsInfoReply;
-        ImsCallPeerDimensionsInfo callPeerDimensionsInfo;
-        callPeerDimensionsInfo.callIndex = DEFAULT_INDEX;
-        ASSERT_TRUE(callPeerDimensionsInfoData.WriteInt32(slotId));
-        ASSERT_TRUE(callPeerDimensionsInfoData.WriteRawData(
-            (const void *)&callPeerDimensionsInfo, sizeof(ImsCallPeerDimensionsInfo)));
-        ASSERT_EQ(stubTestEleven->OnPeerDimensionsChangedInner(
-            callPeerDimensionsInfoData, callPeerDimensionsInfoReply), TELEPHONY_SUCCESS);
-        MessageParcel callDataUsageInfoData;
-        MessageParcel callDataUsageInfoReply;
-        ImsCallDataUsageInfo callDataUsageInfo;
-        callDataUsageInfo.callIndex = DEFAULT_INDEX;
-        ASSERT_TRUE(callDataUsageInfoData.WriteInt32(slotId));
-        ASSERT_TRUE(callDataUsageInfoData.WriteRawData(
-            (const void *)&callDataUsageInfo, sizeof(ImsCallDataUsageInfo)));
-        ASSERT_EQ(stubTestEleven->OnCallDataUsageChangedInner(
-            callDataUsageInfoData, callDataUsageInfoReply), TELEPHONY_SUCCESS);
-        MessageParcel cameraCapabilitiesInfoData;
-        MessageParcel cameraCapabilitiesInfoReply;
-        CameraCapabilitiesInfo cameraCapabilitiesInfo;
-        cameraCapabilitiesInfo.callIndex = DEFAULT_INDEX;
-        ASSERT_TRUE(cameraCapabilitiesInfoData.WriteInt32(slotId));
-        ASSERT_TRUE(cameraCapabilitiesInfoData.WriteRawData(
-            (const void *)&cameraCapabilitiesInfo, sizeof(CameraCapabilitiesInfo)));
-        ASSERT_EQ(stubTestEleven->OnCameraCapabilitiesChangedInner(
-            cameraCapabilitiesInfoData, cameraCapabilitiesInfoReply), TELEPHONY_SUCCESS);
     }
 }
 /**
diff --git a/test/unittest/satellitetest/satellite_callback_test.cpp b/test/unittest/satellitetest/satellite_callback_test.cpp
index 35a4f8c38c8ce382ff55f3a7bac79209e75c987d..0a233b6971823fd295b498307768be55ae89bd7c 100644
--- a/test/unittest/satellitetest/satellite_callback_test.cpp
+++ b/test/unittest/satellitetest/satellite_callback_test.cpp
@@ -156,49 +156,48 @@ HWTEST_F(SatelliteCallbackTest, cellular_call_SatelliteCallCallbackStub_0001, Fu
 {
     sptr<SatelliteCallCallbackStub> stub = (std::make_unique<SatelliteCallCallbackStub>()).release();
     ASSERT_TRUE(stub != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
-        if (!HasSimCard(slotId)) {
-            continue;
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
+            if (!HasSimCard(slotId)) {
+                continue;
+            }
+            RadioResponseInfo rilRadioResponse;
+            rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
+            MessageParcel answerData;
+            MessageParcel answerReply;
+            ASSERT_TRUE(answerData.WriteInt32(slotId));
+            ASSERT_TRUE(answerData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnAnswerResponseInner(answerData, answerReply), TELEPHONY_SUCCESS);
+
+            MessageParcel dialData;
+            MessageParcel dialReply;
+            ASSERT_TRUE(dialData.WriteInt32(slotId));
+            ASSERT_TRUE(dialData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnDialResponseInner(dialData, dialReply), TELEPHONY_SUCCESS);
+
+            MessageParcel CallsData;
+            MessageParcel CallsReply;
+            ASSERT_TRUE(CallsData.WriteInt32(slotId));
+            ASSERT_TRUE(CallsData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnGetSatelliteCallsDataResponseInner(CallsData, CallsReply), TELEPHONY_SUCCESS);
+
+            MessageParcel hangupData;
+            MessageParcel hangupReply;
+            ASSERT_TRUE(hangupData.WriteInt32(slotId));
+            ASSERT_TRUE(hangupData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnHangUpResponseInner(hangupData, hangupReply), TELEPHONY_SUCCESS);
+
+            MessageParcel rejectData;
+            MessageParcel rejectReply;
+            ASSERT_TRUE(rejectData.WriteInt32(slotId));
+            ASSERT_TRUE(rejectData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
+            ASSERT_EQ(stub->OnRejectResponseInner(rejectData, rejectReply), TELEPHONY_SUCCESS);
+
+            MessageParcel statechangeData;
+            MessageParcel statechangeReply;
+            ASSERT_TRUE(statechangeData.WriteInt32(slotId));
+            ASSERT_EQ(stub->OnCallStateChangeReportInner(statechangeData, statechangeReply), TELEPHONY_SUCCESS);
         }
-        RadioResponseInfo rilRadioResponse;
-        rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
-        MessageParcel answerData;
-        MessageParcel answerReply;
-        ASSERT_TRUE(answerData.WriteInt32(slotId));
-        ASSERT_TRUE(answerData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnAnswerResponseInner(answerData, answerReply), TELEPHONY_SUCCESS);
-
-        MessageParcel dialData;
-        MessageParcel dialReply;
-        ASSERT_TRUE(dialData.WriteInt32(slotId));
-        ASSERT_TRUE(dialData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnDialResponseInner(dialData, dialReply), TELEPHONY_SUCCESS);
-
-        MessageParcel CallsData;
-        MessageParcel CallsReply;
-        ASSERT_TRUE(CallsData.WriteInt32(slotId));
-        ASSERT_TRUE(CallsData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnGetSatelliteCallsDataResponseInner(CallsData, CallsReply), TELEPHONY_SUCCESS);
-
-        MessageParcel hangupData;
-        MessageParcel hangupReply;
-        ASSERT_TRUE(hangupData.WriteInt32(slotId));
-        ASSERT_TRUE(hangupData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnHangUpResponseInner(hangupData, hangupReply), TELEPHONY_SUCCESS);
-
-        MessageParcel rejectData;
-        MessageParcel rejectReply;
-        ASSERT_TRUE(rejectData.WriteInt32(slotId));
-        ASSERT_TRUE(rejectData.WriteRawData((const void *)&rilRadioResponse, sizeof(RadioResponseInfo)));
-        ASSERT_EQ(stub->OnRejectResponseInner(rejectData, rejectReply), TELEPHONY_SUCCESS);
-
-        MessageParcel statechangeData;
-        MessageParcel statechangeReply;
-        ASSERT_TRUE(statechangeData.WriteInt32(slotId));
-        ASSERT_EQ(stub->OnCallStateChangeReportInner(statechangeData, statechangeReply), TELEPHONY_SUCCESS);
     }
 }
 
diff --git a/test/unittest/satellitetest/satellite_test.cpp b/test/unittest/satellitetest/satellite_test.cpp
index b30411781a7a8ae7c36cc4ee5f33867e46483771..19e2747b3f318a04705e54590844944b331a1abd 100644
--- a/test/unittest/satellitetest/satellite_test.cpp
+++ b/test/unittest/satellitetest/satellite_test.cpp
@@ -167,9 +167,7 @@ HWTEST_F(SatelliteTest, Satellite_call_DialCall_0001, Function | MediumTest | Le
     ASSERT_TRUE(hangUpCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         int32_t ret = TestDialCallBySatellite(SIM1_SLOTID, PHONE_NUMBER);
         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
@@ -199,9 +197,7 @@ HWTEST_F(SatelliteTest, Satellite_call_HangUpCall_0001, Function | MediumTest |
     ASSERT_TRUE(hangUpCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -233,9 +229,7 @@ HWTEST_F(SatelliteTest, Satellite_call_AnswerCall_0001, Function | MediumTest |
     ASSERT_TRUE(answerCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -267,9 +261,7 @@ HWTEST_F(SatelliteTest, Satellite_call_RejectCall_0001, Function | MediumTest |
     ASSERT_TRUE(rejectCallRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -299,9 +291,7 @@ HWTEST_F(SatelliteTest, Satellite_call_StartDtmf_0001, Function | MediumTest | L
     ASSERT_TRUE(startDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -328,29 +318,28 @@ HWTEST_F(SatelliteTest, Satellite_call_StartDtmf_0001, Function | MediumTest | L
 HWTEST_F(SatelliteTest, Satellite_call_StartDtmf_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(startDtmfRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    CellularCallInfo callInfo;
-    if (HasSimCard(SIM1_SLOTID)) {
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->StartDtmf(code, callInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->StartDtmf(code, callInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(startDtmfRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        CellularCallInfo callInfo;
+        if (HasSimCard(SIM1_SLOTID)) {
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->StartDtmf(code, callInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->StartDtmf(code, callInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -368,9 +357,7 @@ HWTEST_F(SatelliteTest, Satellite_call_StopDtmf_0001, Function | MediumTest | Le
     ASSERT_TRUE(stopDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo callInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
@@ -395,28 +382,27 @@ HWTEST_F(SatelliteTest, Satellite_call_StopDtmf_0001, Function | MediumTest | Le
 HWTEST_F(SatelliteTest, Satellite_call_StopDtmf_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(stopDtmfRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo stopDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->StopDtmf(stopDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo stopDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        ret = telephonyService->StopDtmf(stopDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(stopDtmfRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo stopDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->StopDtmf(stopDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo stopDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            ret = telephonyService->StopDtmf(stopDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 
@@ -434,9 +420,7 @@ HWTEST_F(SatelliteTest, Satellite_call_SendDtmf_0001, Function | MediumTest | Le
     ASSERT_TRUE(sendDtmfRemote != nullptr);
     auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
     ASSERT_TRUE(telephonyService != nullptr);
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
+
     if (HasSimCard(SIM1_SLOTID)) {
         CellularCallInfo sendDtmfCallInfo;
         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
@@ -463,30 +447,29 @@ HWTEST_F(SatelliteTest, Satellite_call_SendDtmf_0001, Function | MediumTest | Le
 HWTEST_F(SatelliteTest, Satellite_call_SendDtmf_0002, Function | MediumTest | Level2)
 {
     AccessToken token;
-    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
-        return;
-    }
-    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ASSERT_TRUE(systemAbilityMgr != nullptr);
-    auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
-    ASSERT_TRUE(sendDtmfRemote != nullptr);
-    auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
-    ASSERT_TRUE(telephonyService != nullptr);
-    if (HasSimCard(SIM1_SLOTID)) {
-        CellularCallInfo sendDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
-    }
-    if (HasSimCard(SIM2_SLOTID)) {
-        CellularCallInfo sendDtmfCallInfo;
-        int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
-        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
-        char code = '1';
-        ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
-        EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+    if (HasSimCard(SIM1_SLOTID) || HasSimCard(SIM2_SLOTID)) {
+        auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        ASSERT_TRUE(systemAbilityMgr != nullptr);
+        auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
+        ASSERT_TRUE(sendDtmfRemote != nullptr);
+        auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
+        ASSERT_TRUE(telephonyService != nullptr);
+        if (HasSimCard(SIM1_SLOTID)) {
+            CellularCallInfo sendDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
+        if (HasSimCard(SIM2_SLOTID)) {
+            CellularCallInfo sendDtmfCallInfo;
+            int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
+            EXPECT_EQ(ret, TELEPHONY_SUCCESS);
+            char code = '1';
+            ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
+            EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
+        }
     }
 }
 } // namespace Telephony
diff --git a/vendor/ims/test/unittest/ims_service_gtest/ims_service_test.cpp b/vendor/ims/test/unittest/ims_service_gtest/ims_service_test.cpp
index 404390241ad8e948e9f7bf7067bc947c21479324..8c1aad2f198ee8fea1dbf05bff0a1d71b871d417 100644
--- a/vendor/ims/test/unittest/ims_service_gtest/ims_service_test.cpp
+++ b/vendor/ims/test/unittest/ims_service_gtest/ims_service_test.cpp
@@ -110,17 +110,16 @@ int32_t ImsServiceTest::InitConditionCheck()
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_DIAL_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        CLIRMode mode = CLIRMode::DEFAULT;
+        ret = imsCallPtr_->Dial(callInfoForSlot0_, mode);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    CLIRMode mode = CLIRMode::DEFAULT;
-    ret = imsCallPtr_->Dial(callInfoForSlot0_, mode);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -130,17 +129,16 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_DIAL_001, Function | MediumTest |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_DIAL_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        CLIRMode mode = CLIRMode::DEFAULT;
+        ret = imsCallPtr_->Dial(callInfoForSlot1_, mode);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    CLIRMode mode = CLIRMode::DEFAULT;
-    ret = imsCallPtr_->Dial(callInfoForSlot1_, mode);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -150,16 +148,15 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_DIAL_002, Function | MediumTest |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_HangUP_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        ret = imsCallPtr_->HangUp(callInfoForSlot0_);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    ret = imsCallPtr_->HangUp(callInfoForSlot0_);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -169,16 +166,15 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_HangUP_001, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_HangUP_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        ret = imsCallPtr_->HangUp(callInfoForSlot1_);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    ret = imsCallPtr_->HangUp(callInfoForSlot1_);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -188,16 +184,15 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_HangUP_002, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_RejectWithReason_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        ret = imsCallPtr_->RejectWithReason(callInfoForSlot0_, ImsRejectReason::USER_DECLINE);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    ret = imsCallPtr_->RejectWithReason(callInfoForSlot0_, ImsRejectReason::USER_DECLINE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -207,16 +202,15 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_RejectWithReason_001, Function | M
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_RejectWithReason_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        ret = imsCallPtr_->RejectWithReason(callInfoForSlot1_, ImsRejectReason::USER_DECLINE);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    ret = imsCallPtr_->RejectWithReason(callInfoForSlot1_, ImsRejectReason::USER_DECLINE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -226,16 +220,15 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_RejectWithReason_002, Function | M
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_Answer_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        ret = imsCallPtr_->Answer(callInfoForSlot0_);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    ret = imsCallPtr_->Answer(callInfoForSlot0_);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -245,16 +238,15 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_Answer_001, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_Answer_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        ret = imsCallPtr_->Answer(callInfoForSlot1_);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    ret = imsCallPtr_->Answer(callInfoForSlot1_);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -264,12 +256,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_Answer_002, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_HoldCall_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->HoldCall(DEFAULT_SLOTID, CALL_TYPE_IMS);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->HoldCall(DEFAULT_SLOTID, CALL_TYPE_IMS);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -279,12 +270,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_HoldCall_001, Function | MediumTes
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_HoldCall_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->HoldCall(SIM_SLOT_ID_1, CALL_TYPE_IMS);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->HoldCall(SIM_SLOT_ID_1, CALL_TYPE_IMS);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -294,12 +284,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_HoldCall_002, Function | MediumTes
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_UnHoldCall_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->UnHoldCall(DEFAULT_SLOTID, CALL_TYPE_IMS);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->UnHoldCall(DEFAULT_SLOTID, CALL_TYPE_IMS);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -309,12 +298,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_UnHoldCall_001, Function | MediumT
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_UnHoldCall_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->UnHoldCall(SIM_SLOT_ID_1, CALL_TYPE_IMS);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->UnHoldCall(SIM_SLOT_ID_1, CALL_TYPE_IMS);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -324,12 +312,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_UnHoldCall_002, Function | MediumT
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SwitchCall_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->SwitchCall(DEFAULT_SLOTID, CALL_TYPE_IMS);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->SwitchCall(DEFAULT_SLOTID, CALL_TYPE_IMS);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -339,12 +326,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SwitchCall_001, Function | MediumT
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SwitchCall_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->SwitchCall(SIM_SLOT_ID_1, CALL_TYPE_IMS);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->SwitchCall(SIM_SLOT_ID_1, CALL_TYPE_IMS);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -354,12 +340,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SwitchCall_002, Function | MediumT
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_CombineConference_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->CombineConference(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->CombineConference(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -369,12 +354,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_CombineConference_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_CombineConference_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->CombineConference(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->CombineConference(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -384,14 +368,13 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_CombineConference_002, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_InviteToConference_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::vector<std::string> numberList;
+        numberList.push_back(PHONE_NUMBER);
+        ret = imsCallPtr_->InviteToConference(DEFAULT_SLOTID, numberList);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::vector<std::string> numberList;
-    numberList.push_back(PHONE_NUMBER);
-    ret = imsCallPtr_->InviteToConference(DEFAULT_SLOTID, numberList);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -401,14 +384,13 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_InviteToConference_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_InviteToConference_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::vector<std::string> numberList;
+        numberList.push_back(PHONE_NUMBER);
+        ret = imsCallPtr_->InviteToConference(SIM_SLOT_ID_1, numberList);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::vector<std::string> numberList;
-    numberList.push_back(PHONE_NUMBER);
-    ret = imsCallPtr_->InviteToConference(SIM_SLOT_ID_1, numberList);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -418,13 +400,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_InviteToConference_002, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_KickOutFromConference_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t index = 1;
+        int32_t ret = imsCallPtr_->KickOutFromConference(DEFAULT_SLOTID, index);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t index = 1;
-    int32_t ret = imsCallPtr_->KickOutFromConference(DEFAULT_SLOTID, index);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -434,13 +415,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_KickOutFromConference_001, Functio
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_KickOutFromConference_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t index = 1;
+        int32_t ret = imsCallPtr_->KickOutFromConference(SIM_SLOT_ID_1, index);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t index = 1;
-    int32_t ret = imsCallPtr_->KickOutFromConference(SIM_SLOT_ID_1, index);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -450,16 +430,15 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_KickOutFromConference_002, Functio
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_UpdateImsCallMode_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot0_, sizeof(callInfoForSlot0_), 0, sizeof(callInfoForSlot0_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        ret = imsCallPtr_->UpdateImsCallMode(callInfoForSlot0_, static_cast<ImsCallMode>(DEFAULT_MODE));
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    ret = imsCallPtr_->UpdateImsCallMode(callInfoForSlot0_, static_cast<ImsCallMode>(DEFAULT_MODE));
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -469,16 +448,15 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_UpdateImsCallMode_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_UpdateImsCallMode_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
-        ret = TELEPHONY_SUCCESS;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (memset_s(&callInfoForSlot1_, sizeof(callInfoForSlot1_), 0, sizeof(callInfoForSlot1_)) == EOK) {
+            ret = TELEPHONY_SUCCESS;
+        }
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
+        ret = imsCallPtr_->UpdateImsCallMode(callInfoForSlot1_, static_cast<ImsCallMode>(DEFAULT_MODE));
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-    ret = imsCallPtr_->UpdateImsCallMode(callInfoForSlot1_, static_cast<ImsCallMode>(DEFAULT_MODE));
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -488,13 +466,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_UpdateImsCallMode_002, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_StartDtmf_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        char dtmfCode = '#';
+        ret = imsCallPtr_->StartDtmf(DEFAULT_SLOTID, dtmfCode, DEFAULT_INDEX);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    char dtmfCode = '#';
-    ret = imsCallPtr_->StartDtmf(DEFAULT_SLOTID, dtmfCode, DEFAULT_INDEX);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -504,13 +481,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_StartDtmf_001, Function | MediumTe
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_StartDtmf_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        char dtmfCode = '#';
+        ret = imsCallPtr_->StartDtmf(SIM_SLOT_ID_1, dtmfCode, DEFAULT_INDEX);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    char dtmfCode = '#';
-    ret = imsCallPtr_->StartDtmf(SIM_SLOT_ID_1, dtmfCode, DEFAULT_INDEX);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -520,13 +496,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_StartDtmf_002, Function | MediumTe
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SendDtmf_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        char dtmfCode = '#';
+        ret = imsCallPtr_->SendDtmf(DEFAULT_SLOTID, dtmfCode, DEFAULT_INDEX);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    char dtmfCode = '#';
-    ret = imsCallPtr_->SendDtmf(DEFAULT_SLOTID, dtmfCode, DEFAULT_INDEX);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -536,13 +511,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SendDtmf_001, Function | MediumTes
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SendDtmf_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        char dtmfCode = '#';
+        ret = imsCallPtr_->SendDtmf(SIM_SLOT_ID_1, dtmfCode, DEFAULT_INDEX);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    char dtmfCode = '#';
-    ret = imsCallPtr_->SendDtmf(SIM_SLOT_ID_1, dtmfCode, DEFAULT_INDEX);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -552,12 +526,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SendDtmf_002, Function | MediumTes
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_StopDtmf_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->StopDtmf(DEFAULT_SLOTID, DEFAULT_INDEX);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->StopDtmf(DEFAULT_SLOTID, DEFAULT_INDEX);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -567,12 +540,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_StopDtmf_001, Function | MediumTes
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_StopDtmf_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->StopDtmf(SIM_SLOT_ID_1, DEFAULT_INDEX);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->StopDtmf(SIM_SLOT_ID_1, DEFAULT_INDEX);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -582,12 +554,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_StopDtmf_002, Function | MediumTes
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_StartRtt_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->StartRtt(DEFAULT_SLOTID, RTT_MSG);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->StartRtt(DEFAULT_SLOTID, RTT_MSG);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -597,12 +568,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_StartRtt_001, Function | MediumTes
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_StartRtt_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->StartRtt(SIM_SLOT_ID_1, RTT_MSG);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->StartRtt(SIM_SLOT_ID_1, RTT_MSG);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -612,12 +582,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_StartRtt_002, Function | MediumTes
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_StopRtt_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->StopRtt(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->StopRtt(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -627,12 +596,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_StopRtt_001, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_StopRtt_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->StopRtt(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->StopRtt(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -642,12 +610,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_StopRtt_002, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetDomainPreferenceMode_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->SetDomainPreferenceMode(DEFAULT_SLOTID, DEFAULT_MODE);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->SetDomainPreferenceMode(DEFAULT_SLOTID, DEFAULT_MODE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -657,12 +624,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetDomainPreferenceMode_001, Funct
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetDomainPreferenceMode_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->SetDomainPreferenceMode(SIM_SLOT_ID_1, DEFAULT_MODE);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->SetDomainPreferenceMode(SIM_SLOT_ID_1, DEFAULT_MODE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -672,12 +638,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetDomainPreferenceMode_002, Funct
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetDomainPreferenceMode_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetDomainPreferenceMode(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetDomainPreferenceMode(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -687,12 +652,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetDomainPreferenceMode_001, Funct
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetDomainPreferenceMode_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetDomainPreferenceMode(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetDomainPreferenceMode(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -702,12 +666,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetDomainPreferenceMode_002, Funct
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsSwitchStatus_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->SetImsSwitchStatus(DEFAULT_SLOTID, DEFAULT_ACTIVE);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->SetImsSwitchStatus(DEFAULT_SLOTID, DEFAULT_ACTIVE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -717,12 +680,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsSwitchStatus_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsSwitchStatus_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->SetImsSwitchStatus(SIM_SLOT_ID_1, DEFAULT_ACTIVE);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->SetImsSwitchStatus(SIM_SLOT_ID_1, DEFAULT_ACTIVE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -732,12 +694,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsSwitchStatus_002, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsSwitchStatus_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetImsSwitchStatus(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetImsSwitchStatus(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -747,12 +708,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsSwitchStatus_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsSwitchStatus_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetImsSwitchStatus(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetImsSwitchStatus(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -762,13 +722,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsSwitchStatus_002, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsConfigString_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::string value = "0";
+        ret = imsCallPtr_->SetImsConfig(DEFAULT_ITEM, value);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::string value = "0";
-    ret = imsCallPtr_->SetImsConfig(DEFAULT_ITEM, value);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -778,13 +737,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsConfigString_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsConfigInt_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t value = 0;
+        ret = imsCallPtr_->SetImsConfig(DEFAULT_ITEM, value);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t value = 0;
-    ret = imsCallPtr_->SetImsConfig(DEFAULT_ITEM, value);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -794,12 +752,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsConfigInt_001, Function | Me
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsConfig_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetImsConfig(DEFAULT_ITEM);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetImsConfig(DEFAULT_ITEM);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -809,13 +766,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsConfig_001, Function | Mediu
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsFeatureValue_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t value = 0;
+        ret = imsCallPtr_->SetImsFeatureValue(DEFAULT_FEATURE_TYPE, value);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t value = 0;
-    ret = imsCallPtr_->SetImsFeatureValue(DEFAULT_FEATURE_TYPE, value);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -825,14 +781,13 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetImsFeatureValue_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsFeatureValue_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t value;
+        ret = imsCallPtr_->GetImsFeatureValue(DEFAULT_FEATURE_TYPE, value);
+        TELEPHONY_LOGI("Ims Feature Value:%{public}d", value);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t value;
-    ret = imsCallPtr_->GetImsFeatureValue(DEFAULT_FEATURE_TYPE, value);
-    TELEPHONY_LOGI("Ims Feature Value:%{public}d", value);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -842,13 +797,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsFeatureValue_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetMute_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t mute = 0;
+        ret = imsCallPtr_->SetMute(DEFAULT_SLOTID, mute);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t mute = 0;
-    ret = imsCallPtr_->SetMute(DEFAULT_SLOTID, mute);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -858,13 +812,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetMute_001, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetMute_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t mute = 0;
+        ret = imsCallPtr_->SetMute(SIM_SLOT_ID_1, mute);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t mute = 0;
-    ret = imsCallPtr_->SetMute(SIM_SLOT_ID_1, mute);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -874,12 +827,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetMute_002, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetMute_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetMute(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetMute(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 /**
  * @tc.number   Telephony_ImsService_GetMute_002
@@ -888,12 +840,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetMute_001, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetMute_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetMute(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetMute(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -903,15 +854,14 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetMute_002, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_CtrlCamera_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::u16string cameraId = u"cameraId";
+        int32_t callingUid = 0;
+        int32_t callingPid = 0;
+        ret = imsCallPtr_->CtrlCamera(cameraId, callingUid, callingPid);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::u16string cameraId = u"cameraId";
-    int32_t callingUid = 0;
-    int32_t callingPid = 0;
-    ret = imsCallPtr_->CtrlCamera(cameraId, callingUid, callingPid);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -921,17 +871,16 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_CtrlCamera_001, Function | MediumT
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetPreviewWindow_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t x = 0;
+        int32_t y = 0;
+        int32_t z = 0;
+        int32_t width = 0;
+        int32_t height = 0;
+        ret = imsCallPtr_->SetPreviewWindow(x, y, z, width, height);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t x = 0;
-    int32_t y = 0;
-    int32_t z = 0;
-    int32_t width = 0;
-    int32_t height = 0;
-    ret = imsCallPtr_->SetPreviewWindow(x, y, z, width, height);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -941,17 +890,16 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetPreviewWindow_001, Function | M
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetDisplayWindow_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t x = 0;
+        int32_t y = 0;
+        int32_t z = 0;
+        int32_t width = 0;
+        int32_t height = 0;
+        ret = imsCallPtr_->SetDisplayWindow(x, y, z, width, height);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t x = 0;
-    int32_t y = 0;
-    int32_t z = 0;
-    int32_t width = 0;
-    int32_t height = 0;
-    ret = imsCallPtr_->SetDisplayWindow(x, y, z, width, height);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -961,13 +909,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetDisplayWindow_001, Function | M
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCameraZoom_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        float zoomRatio = 1.0;
+        ret = imsCallPtr_->SetCameraZoom(zoomRatio);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    float zoomRatio = 1.0;
-    ret = imsCallPtr_->SetCameraZoom(zoomRatio);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -977,13 +924,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCameraZoom_001, Function | Medi
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetPauseImage_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::u16string path = u"path";
+        ret = imsCallPtr_->SetPauseImage(path);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::u16string path = u"path";
-    ret = imsCallPtr_->SetPauseImage(path);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -993,13 +939,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetPauseImage_001, Function | Medi
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetDeviceDirection_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t rotation = 0;
+        ret = imsCallPtr_->SetDeviceDirection(rotation);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t rotation = 0;
-    ret = imsCallPtr_->SetDeviceDirection(rotation);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1009,12 +954,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetDeviceDirection_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetClip_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetClip(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetClip(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1024,12 +968,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetClip_001, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetClip_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetClip(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetClip(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1039,13 +982,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetClip_002, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetClir_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t action = 0;
+        ret = imsCallPtr_->SetClir(DEFAULT_SLOTID, action);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t action = 0;
-    ret = imsCallPtr_->SetClir(DEFAULT_SLOTID, action);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1055,13 +997,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetClir_001, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetClir_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t action = 0;
+        ret = imsCallPtr_->SetClir(SIM_SLOT_ID_1, action);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t action = 0;
-    ret = imsCallPtr_->SetClir(SIM_SLOT_ID_1, action);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1071,12 +1012,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetClir_002, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetClir_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetClir(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetClir(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1086,12 +1026,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetClir_001, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetClir_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetClir(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetClir(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1101,14 +1040,13 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetClir_002, Function | MediumTest
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallTransfer_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::string transferNum = "000000";
+        int32_t classType = 1;
+        ret = imsCallPtr_->SetCallTransfer(DEFAULT_SLOTID, DEFAULT_TRANSFER_TYPE, DEFAULT_MODE, transferNum, classType);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::string transferNum = "000000";
-    int32_t classType = 1;
-    ret = imsCallPtr_->SetCallTransfer(DEFAULT_SLOTID, DEFAULT_TRANSFER_TYPE, DEFAULT_MODE, transferNum, classType);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1118,14 +1056,13 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallTransfer_001, Function | Me
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallTransfer_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::string transferNum = "000000";
+        int32_t classType = 1;
+        ret = imsCallPtr_->SetCallTransfer(SIM_SLOT_ID_1, DEFAULT_TRANSFER_TYPE, DEFAULT_MODE, transferNum, classType);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::string transferNum = "000000";
-    int32_t classType = 1;
-    ret = imsCallPtr_->SetCallTransfer(SIM_SLOT_ID_1, DEFAULT_TRANSFER_TYPE, DEFAULT_MODE, transferNum, classType);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1135,17 +1072,15 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallTransfer_002, Function | Me
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallTransfer_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
-    }
-    int32_t ret = TELEPHONY_ERROR;
-    if (imsCallPtr_ == nullptr) {
-        TELEPHONY_LOGE("imsCallPtr is nullptr, Init Failed!");
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        if (imsCallPtr_ == nullptr) {
+            TELEPHONY_LOGE("imsCallPtr is nullptr, Init Failed!");
+            ASSERT_EQ(TELEPHONY_SUCCESS, ret);
+        }
+        ret = imsCallPtr_->GetCallTransfer(DEFAULT_SLOTID, DEFAULT_TRANSFER_TYPE);
         EXPECT_EQ(TELEPHONY_SUCCESS, ret);
-        return;
     }
-    ret = imsCallPtr_->GetCallTransfer(DEFAULT_SLOTID, DEFAULT_TRANSFER_TYPE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1155,12 +1090,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallTransfer_001, Function | Me
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallTransfer_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetCallTransfer(SIM_SLOT_ID_1, DEFAULT_TRANSFER_TYPE);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetCallTransfer(SIM_SLOT_ID_1, DEFAULT_TRANSFER_TYPE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1170,14 +1104,13 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallTransfer_002, Function | Me
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallRestriction_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::string fac = "AO";
+        std::string password = "000000";
+        ret = imsCallPtr_->SetCallRestriction(DEFAULT_SLOTID, fac, DEFAULT_MODE, password);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::string fac = "AO";
-    std::string password = "000000";
-    ret = imsCallPtr_->SetCallRestriction(DEFAULT_SLOTID, fac, DEFAULT_MODE, password);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1187,14 +1120,13 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallRestriction_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallRestriction_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::string fac = "AO";
+        std::string password = "000000";
+        ret = imsCallPtr_->SetCallRestriction(SIM_SLOT_ID_1, fac, DEFAULT_MODE, password);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::string fac = "AO";
-    std::string password = "000000";
-    ret = imsCallPtr_->SetCallRestriction(SIM_SLOT_ID_1, fac, DEFAULT_MODE, password);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1204,13 +1136,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallRestriction_002, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallRestriction_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::string facType = "AO";
+        ret = imsCallPtr_->GetCallRestriction(DEFAULT_SLOTID, facType);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::string facType = "AO";
-    ret = imsCallPtr_->GetCallRestriction(DEFAULT_SLOTID, facType);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1220,13 +1151,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallRestriction_001, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallRestriction_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        std::string facType = "AO";
+        ret = imsCallPtr_->GetCallRestriction(SIM_SLOT_ID_1, facType);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    std::string facType = "AO";
-    ret = imsCallPtr_->GetCallRestriction(SIM_SLOT_ID_1, facType);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1236,12 +1166,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallRestriction_002, Function |
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallWaiting_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->SetCallWaiting(DEFAULT_SLOTID, DEFAULT_ACTIVE, ServiceClassType::VOICE);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->SetCallWaiting(DEFAULT_SLOTID, DEFAULT_ACTIVE, ServiceClassType::VOICE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1251,12 +1180,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallWaiting_001, Function | Med
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallWaiting_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->SetCallWaiting(SIM_SLOT_ID_1, DEFAULT_ACTIVE, ServiceClassType::VOICE);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->SetCallWaiting(SIM_SLOT_ID_1, DEFAULT_ACTIVE, ServiceClassType::VOICE);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1266,12 +1194,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetCallWaiting_002, Function | Med
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallWaiting_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetCallWaiting(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetCallWaiting(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1281,12 +1208,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallWaiting_001, Function | Med
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallWaiting_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCallPtr_->GetCallWaiting(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCallPtr_->GetCallWaiting(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1296,13 +1222,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetCallWaiting_002, Function | Med
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetSmsConfig_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t imsSmsConfig = 1;
+        ret = imsSmsPtr_->ImsSetSmsConfig(DEFAULT_SLOTID, imsSmsConfig);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t imsSmsConfig = 1;
-    ret = imsSmsPtr_->ImsSetSmsConfig(DEFAULT_SLOTID, imsSmsConfig);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1312,13 +1237,12 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetSmsConfig_001, Function | Mediu
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SetSmsConfig_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t imsSmsConfig = 1;
+        ret = imsSmsPtr_->ImsSetSmsConfig(SIM_SLOT_ID_1, imsSmsConfig);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t imsSmsConfig = 1;
-    ret = imsSmsPtr_->ImsSetSmsConfig(SIM_SLOT_ID_1, imsSmsConfig);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1328,12 +1252,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SetSmsConfig_002, Function | Mediu
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetSmsConfig_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsSmsPtr_->ImsGetSmsConfig(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsSmsPtr_->ImsGetSmsConfig(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1343,12 +1266,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetSmsConfig_001, Function | Mediu
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetSmsConfig_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsSmsPtr_->ImsGetSmsConfig(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsSmsPtr_->ImsGetSmsConfig(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1358,15 +1280,14 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetSmsConfig_002, Function | Mediu
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SendMessage_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t refld = 1;
+        ImsMessageInfo imsMessageInfo;
+        imsMessageInfo.refId = refld;
+        ret = imsSmsPtr_->ImsSendMessage(DEFAULT_SLOTID, imsMessageInfo);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t refld = 1;
-    ImsMessageInfo imsMessageInfo;
-    imsMessageInfo.refId = refld;
-    ret = imsSmsPtr_->ImsSendMessage(DEFAULT_SLOTID, imsMessageInfo);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1376,15 +1297,14 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SendMessage_001, Function | Medium
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_SendMessage_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        int32_t refld = 1;
+        ImsMessageInfo imsMessageInfo;
+        imsMessageInfo.refId = refld;
+        ret = imsSmsPtr_->ImsSendMessage(SIM_SLOT_ID_1, imsMessageInfo);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    int32_t refld = 1;
-    ImsMessageInfo imsMessageInfo;
-    imsMessageInfo.refId = refld;
-    ret = imsSmsPtr_->ImsSendMessage(SIM_SLOT_ID_1, imsMessageInfo);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1394,12 +1314,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_SendMessage_002, Function | Medium
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsRegistrationStatus_001, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(DEFAULT_SLOTID)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCoreServicePtr_->GetImsRegistrationStatus(DEFAULT_SLOTID);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCoreServicePtr_->GetImsRegistrationStatus(DEFAULT_SLOTID);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 
 /**
@@ -1409,12 +1328,11 @@ HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsRegistrationStatus_001, Func
  */
 HWTEST_F(ImsServiceTest, Telephony_ImsService_GetImsRegistrationStatus_002, Function | MediumTest | Level1)
 {
-    if ((ImsServiceTest::InitConditionCheck() != TELEPHONY_SUCCESS) || !HasSimCard(SIM_SLOT_ID_1)) {
-        return;
+    if ((ImsServiceTest::InitConditionCheck() == TELEPHONY_SUCCESS) && HasSimCard(DEFAULT_SLOTID)) {
+        int32_t ret = TELEPHONY_ERROR;
+        ret = imsCoreServicePtr_->GetImsRegistrationStatus(SIM_SLOT_ID_1);
+        EXPECT_EQ(TELEPHONY_SUCCESS, ret);
     }
-    int32_t ret = TELEPHONY_ERROR;
-    ret = imsCoreServicePtr_->GetImsRegistrationStatus(SIM_SLOT_ID_1);
-    EXPECT_EQ(TELEPHONY_SUCCESS, ret);
 }
 } // namespace Telephony
 } // namespace OHOS