diff --git a/test/unittest/phone/qos_interface_test.cpp b/test/unittest/phone/qos_interface_test.cpp
index fbe16f856cfa33bfae774be2be7023a5004be440..9245e82581f556f73e0d37315e62a67267cdc1a7 100644
--- a/test/unittest/phone/qos_interface_test.cpp
+++ b/test/unittest/phone/qos_interface_test.cpp
@@ -69,74 +69,95 @@ extern "C" {
 HWTEST_F(QosInterfaceTest, EnableRtgTest, TestSize.Level1)
 {
     bool flag = true;
-    int ret = EnableRtg(flag);
-    EXPECT_EQ(ret, 0);
+    int val = EnableRtg(flag);
+    EXPECT_EQ(val, 0);
 }
 
 /**
- * @tc.name: QosApplyTest1
+ * @tc.name: QosApplyTest
  * @tc.desc: Test whether the QosApply interface are normal.
  * @tc.type: FUNC
  */
 HWTEST_F(QosInterfaceTest, QosApplyTest1, TestSize.Level1)
 {
     unsigned int level = 1;
-    int ret = -1;
-    ret = QosApply(level);
+    int val = -1;
+    val = QosApply(level);
 #if defined(ARM64_TEST) && ARM64_TEST
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
 #else
-    (void)ret;
+    (void)val;
 #endif
 }
 
 /**
- * @tc.name: QosApplyTest2
+ * @tc.name: QosApplyFuncTest
  * @tc.desc: Test whether the QosApply interface are normal.
  * @tc.type: FUNC
  */
-HWTEST_F(QosInterfaceTest, QosApplyTest2, TestSize.Level1)
+HWTEST_F(QosInterfaceTest, QosApplyFuncTest0, TestSize.Level0)
 {
     unsigned int level = 0;
-    int ret = -1;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 1;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyFuncTest1, TestSize.Level0)
+{
+    unsigned int level = 1;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 2;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyFuncTest2, TestSize.Level0)
+{
+    unsigned int level = 2;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 3;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyFuncTest3, TestSize.Level0)
+{
+    unsigned int level = 3;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 4;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyFuncTest4, TestSize.Level0)
+{
+    unsigned int level = 4;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosApplyFuncTest5, TestSize.Level0)
+{
+    unsigned int level = 5;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 5;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyFuncTest6, TestSize.Level1)
+{
+    unsigned int level = 6;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 6;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
 
-    level = 7;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, -1);
+HWTEST_F(QosInterfaceTest, QosApplyFuncTestExt, TestSize.Level1)
+{
+    unsigned int level = 7;
+    int val = QosApply(level);
+    EXPECT_EQ(val, -1);
 
     level = 1024;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, -1);
+    val = QosApply(level);
+    EXPECT_EQ(val, -1);
 }
 
 /**
- * @tc.name: QosApplyForOtherTest1
+ * @tc.name: QosApplyForOtherTest
  * @tc.desc: Test whether the QosApplyForOther interface are normal.
  * @tc.type: FUNC
  */
@@ -144,193 +165,283 @@ HWTEST_F(QosInterfaceTest, QosApplyForOtherTest1, TestSize.Level1)
 {
     unsigned int level = 1;
     int tid = gettid();
-    int ret = -1;
-    ret = QosApplyForOther(level, tid);
+    int val = -1;
+    val = QosApplyForOther(level, tid);
 #if defined(ARM64_TEST) && ARM64_TEST
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
 #else
-    (void)ret;
+    (void)val;
 #endif
 }
 
 /**
- * @tc.name: QosApplyForOtherTest2
+ * @tc.name: QosApplyForOtherFuncTest
  * @tc.desc: Test whether the QosApplyForOther interface are normal.
  * @tc.type: FUNC
  */
-HWTEST_F(QosInterfaceTest, QosApplyForOtherTest2, TestSize.Level1)
+HWTEST_F(QosInterfaceTest, QosApplyForOtherFuncTest0, TestSize.Level0)
 {
     unsigned int level = 0;
     int tid = gettid();
-    int ret = -1;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 1;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyForOtherFuncTest1, TestSize.Level0)
+{
+    unsigned int level = 1;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 2;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyForOtherFuncTest2, TestSize.Level0)
+{
+    unsigned int level = 2;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 3;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyForOtherFuncTest3, TestSize.Level0)
+{
+    unsigned int level = 3;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 4;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyForOtherFuncTest4, TestSize.Level0)
+{
+    unsigned int level = 4;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 5;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyForOtherFuncTest5, TestSize.Level0)
+{
+    unsigned int level = 5;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 6;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosApplyForOtherFuncTest6, TestSize.Level1)
+{
+    unsigned int level = 6;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+}
 
-    level = 7;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, -1);
+HWTEST_F(QosInterfaceTest, QosApplyForOtherFuncTestExt, TestSize.Level1)
+{
+    unsigned int level = 7;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, -1);
 
     level = 1024;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, -1);
+    val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, -1);
 }
 
 /**
- * @tc.name: QosLeaveTest1
+ * @tc.name: QosLeaveTest
  * @tc.desc: Test whether the QosLeave interface are normal.
  * @tc.type: FUNC
  */
-HWTEST_F(QosInterfaceTest, QosLeaveTest1, TestSize.Level1)
+HWTEST_F(QosInterfaceTest, QosLeaveTest, TestSize.Level1)
 {
-    int ret = -1;
-    ret = QosLeave();
+    int val = -1;
+    val = QosLeave();
 #if defined(ARM64_TEST) && ARM64_TEST
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
 #else
-    (void)ret;
+    (void)val;
 #endif
 }
 
 /**
- * @tc.name: QosLeaveTest2
+ * @tc.name: QosLeaveFuncTest
  * @tc.desc: Test whether the QosLeave interface are normal.
  * @tc.type: FUNC
  */
-HWTEST_F(QosInterfaceTest, QosLeaveTest2, TestSize.Level1)
-{
-    int ret = -1;
-    ret = QosApply(0);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeave();
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApply(1);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeave();
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApply(2);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeave();
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApply(3);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeave();
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApply(4);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeave();
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApply(5);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeave();
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApply(6);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeave();
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApply(7);
-    EXPECT_EQ(ret, -1);
-    ret = QosLeave();
-    EXPECT_EQ(ret, -1);
+HWTEST_F(QosInterfaceTest, QosLeaveFuncTestExt0, TestSize.Level0)
+{
+    int level = 0;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosLeave();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveFuncTestExt1, TestSize.Level0)
+{
+    int level = 1;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosLeave();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveFuncTestExt2, TestSize.Level0)
+{
+    int level = 2;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosLeave();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveFuncTestExt3, TestSize.Level0)
+{
+    int level = 3;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosLeave();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveFuncTestExt4, TestSize.Level0)
+{
+    int level = 4;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosLeave();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveFuncTestExt5, TestSize.Level0)
+{
+    int level = 5;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosLeave();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveFuncTestExt6, TestSize.Level1)
+{
+    int level = 6;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosLeave();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveFuncTestExt, TestSize.Level1)
+{
+    int val = -1;
+    val = QosApply(7);
+    EXPECT_EQ(val, -1);
+    val = QosLeave();
+    EXPECT_EQ(val, -1);
 }
 
 /**
- * @tc.name: QosLeaveForOtherTest1
+ * @tc.name: QosLeaveForOtherTest
  * @tc.desc: Test whether the QosLeaveForOther interface are normal.
  * @tc.type: FUNC
  */
-HWTEST_F(QosInterfaceTest, QosLeaveForOtherTest1, TestSize.Level1)
+HWTEST_F(QosInterfaceTest, QosLeaveForOtherTest, TestSize.Level1)
 {
-    int ret = -1;
+    int val = -1;
     int tid = gettid();
     int level = 1;
-    ret = QosApplyForOther(level, tid);
-    ret = QosLeaveForOther(tid);
+    val = QosApplyForOther(level, tid);
+    val = QosLeaveForOther(tid);
 #if defined(ARM64_TEST) && ARM64_TEST
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
 #else
-    (void)ret;
+    (void)val;
 #endif
 }
 
 /**
- * @tc.name: QosLeaveForOtherTest2
+ * @tc.name: QosLeaveForOtherFuncTest
  * @tc.desc: Test whether the QosLeaveForOther interface are normal.
  * @tc.type: FUNC
  */
-HWTEST_F(QosInterfaceTest, QosLeaveForOtherTest2, TestSize.Level1)
+HWTEST_F(QosInterfaceTest, QosLeaveForOtherFuncTest0, TestSize.Level0)
 {
-    int ret = -1;
+    int level = 0;
     int tid = gettid();
-    ret = QosApplyForOther(0, tid);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeaveForOther(tid);
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApplyForOther(1, tid);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeaveForOther(tid);
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApplyForOther(2, tid);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeaveForOther(tid);
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApplyForOther(3, tid);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeaveForOther(tid);
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApplyForOther(4, tid);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeaveForOther(tid);
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApplyForOther(5, tid);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeaveForOther(tid);
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApplyForOther(6, tid);
-    EXPECT_EQ(ret, 0);
-    ret = QosLeaveForOther(tid);
-    EXPECT_EQ(ret, 0);
-
-    ret = QosApplyForOther(7, tid);
-    EXPECT_EQ(ret, -1);
-    ret = QosLeaveForOther(tid);
-    EXPECT_EQ(ret, -1);
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+    val = QosLeaveForOther(tid);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveForOtherFuncTest1, TestSize.Level0)
+{
+    int level = 1;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+    val = QosLeaveForOther(tid);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveForOtherFuncTest2, TestSize.Level0)
+{
+    int level = 2;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+    val = QosLeaveForOther(tid);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveForOtherFuncTest3, TestSize.Level0)
+{
+    int level = 3;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+    val = QosLeaveForOther(tid);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveForOtherFuncTest4, TestSize.Level0)
+{
+    int level = 4;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+    val = QosLeaveForOther(tid);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveForOtherFuncTest5, TestSize.Level0)
+{
+    int level = 5;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+    val = QosLeaveForOther(tid);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveForOtherFuncTest6, TestSize.Level1)
+{
+    int level = 6;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
+    val = QosLeaveForOther(tid);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosInterfaceTest, QosLeaveForOtherFuncTest, TestSize.Level1)
+{
+    int level = 7;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, -1);
+    val = QosLeaveForOther(tid);
+    EXPECT_EQ(val, -1);
 }
 
 /**
@@ -355,10 +466,10 @@ static struct QosPolicyDatas g_defaultQosPolicy = {
 
 HWTEST_F(QosInterfaceTest, QosPolicyTest, TestSize.Level1)
 {
-    int ret = -1;
+    int val = -1;
     struct QosPolicyDatas *policyDatas = nullptr;
-    ret = QosPolicySet(policyDatas);
-    EXPECT_EQ(ret, -1);
+    val = QosPolicySet(policyDatas);
+    EXPECT_EQ(val, -1);
 }
 
 /**
@@ -370,161 +481,196 @@ HWTEST_F(QosInterfaceTest, QosGetTest1, TestSize.Level1)
 {
     int qos;
     unsigned int level = 4;
-    int ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
-    ret = QosGet(qos);
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosGet(qos);
     sleep(5);
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
 }
 
 /**
- * @tc.name: QosGetTest2
+ * @tc.name: QosGetFuncTest
  * @tc.desc: Test whether the QosGet interface are normal.
  * @tc.type: FUNC
  */
-HWTEST_F(QosInterfaceTest, QosGetTest2, TestSize.Level1)
+HWTEST_F(QosInterfaceTest, QosGetFuncTest0, TestSize.Level0)
 {
-    int qos;
+    int qos = -1;
     unsigned int level = 0;
-    int ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
-    ret = QosGet(qos);
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosGet(qos);
     sleep(1);
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 1;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
-    ret = QosGet(qos);
+HWTEST_F(QosInterfaceTest, QosGetFuncTest1, TestSize.Level0)
+{
+    int qos = -1;
+    unsigned int level = 1;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosGet(qos);
     sleep(1);
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 2;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
-    ret = QosGet(qos);
+HWTEST_F(QosInterfaceTest, QosGetFuncTest2, TestSize.Level0)
+{
+    int qos = -1;
+    unsigned int level = 2;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosGet(qos);
     sleep(1);
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 3;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
-    ret = QosGet(qos);
+HWTEST_F(QosInterfaceTest, QosGetFuncTest3, TestSize.Level0)
+{
+    int qos = -1;
+    unsigned int level = 3;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosGet(qos);
     sleep(1);
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
 }
 
-/**
- * @tc.name: QosGetTest3
- * @tc.desc: Test whether the QosGet interface are normal.
- * @tc.type: FUNC
- */
-HWTEST_F(QosInterfaceTest, QosGetTest3, TestSize.Level1)
+HWTEST_F(QosInterfaceTest, QosGetFuncTest4, TestSize.Level0)
 {
-    int qos;
+    int qos = -1;
     unsigned int level = 4;
-    int ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
-    ret = QosGet(qos);
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosGet(qos);
     sleep(1);
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 5;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
-    ret = QosGet(qos);
+HWTEST_F(QosInterfaceTest, QosGetFuncTest5, TestSize.Level0)
+{
+    int qos = -1;
+    unsigned int level = 5;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosGet(qos);
     sleep(1);
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 6;
-    ret = QosApply(level);
-    EXPECT_EQ(ret, 0);
-    ret = QosGet(qos);
+HWTEST_F(QosInterfaceTest, QosGetFuncTest6, TestSize.Level1)
+{
+    int qos = -1;
+    unsigned int level = 6;
+    int val = QosApply(level);
+    EXPECT_EQ(val, 0);
+    val = QosGet(qos);
     sleep(1);
-    EXPECT_EQ(ret, 0);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
 }
 
 /**
- * @tc.name: QosGetForOtherTest1
+ * @tc.name: QosGetForOtherFuncTest
  * @tc.desc: Test whether the QosGetForOther interface are normal.
  * @tc.type: FUNC
  */
-HWTEST_F(QosInterfaceTest, QosGetForOtherTest1, TestSize.Level1)
+HWTEST_F(QosInterfaceTest, QosGetForOtherTest0, TestSize.Level0)
 {
-    int qos;
+    int qos = -1;
     unsigned int level = 0;
     int tid = gettid();
-    int ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
     sleep(1);
-    ret = QosGetForOther(tid, qos);
-    EXPECT_EQ(ret, 0);
+    val = QosGetForOther(tid, qos);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 1;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosGetForOtherTest1, TestSize.Level0)
+{
+    int qos = -1;
+    unsigned int level = 1;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
     sleep(1);
-    ret = QosGetForOther(tid, qos);
-    EXPECT_EQ(ret, 0);
+    val = QosGetForOther(tid, qos);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 2;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosGetForOtherTest2, TestSize.Level0)
+{
+    int qos = -1;
+    unsigned int level = 2;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
     sleep(1);
-    ret = QosGetForOther(tid, qos);
-    EXPECT_EQ(ret, 0);
+    val = QosGetForOther(tid, qos);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 3;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosGetForOtherTest3, TestSize.Level0)
+{
+    int qos = -1;
+    unsigned int level = 3;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
     sleep(1);
-    ret = QosGetForOther(tid, qos);
-    EXPECT_EQ(ret, 0);
+    val = QosGetForOther(tid, qos);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
 }
 
-/**
- * @tc.name: QosGetForOtherTest2
- * @tc.desc: Test whether the QosGetForOther interface are normal.
- * @tc.type: FUNC
- */
-HWTEST_F(QosInterfaceTest, QosGetForOtherTest2, TestSize.Level1)
+HWTEST_F(QosInterfaceTest, QosGetForOtherTest4, TestSize.Level0)
 {
-    int qos;
+    int qos = -1;
     unsigned int level = 4;
     int tid = gettid();
-    int ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
     sleep(1);
-    ret = QosGetForOther(tid, qos);
-    EXPECT_EQ(ret, 0);
+    val = QosGetForOther(tid, qos);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 5;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosGetForOtherTest5, TestSize.Level0)
+{
+    int qos = -1;
+    unsigned int level = 5;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
     sleep(1);
-    ret = QosGetForOther(tid, qos);
-    EXPECT_EQ(ret, 0);
+    val = QosGetForOther(tid, qos);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
+}
 
-    level = 6;
-    ret = QosApplyForOther(level, tid);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosInterfaceTest, QosGetForOtherTest6, TestSize.Level0)
+{
+    int qos = -1;
+    unsigned int level = 6;
+    int tid = gettid();
+    int val = QosApplyForOther(level, tid);
+    EXPECT_EQ(val, 0);
     sleep(1);
-    ret = QosGetForOther(tid, qos);
-    EXPECT_EQ(ret, 0);
+    val = QosGetForOther(tid, qos);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(qos, level);
 }
 }
diff --git a/test/unittest/phone/qos_ndk_test.cpp b/test/unittest/phone/qos_ndk_test.cpp
index ad6686fe016d2fa4d1def15b381934e67b2aebe2..badd257c16d97a16f3c2f16e2190d644a7936600 100644
--- a/test/unittest/phone/qos_ndk_test.cpp
+++ b/test/unittest/phone/qos_ndk_test.cpp
@@ -49,111 +49,184 @@ void QoSNdkTest::TearDown()
 }
 
 /**
- * @tc.name: QoSNdkTest
- * @tc.desc: Verify the Set and Reset QoSLevel function.
+ * @tc.name: SetThreadQoSNdkTest
+ * @tc.desc: Verify the Set QoSLevel function.
  * @tc.type: FUNC
  */
-HWTEST_F(QoSNdkTest, SetThreadQoSNdkTest1, TestSize.Level1)
-{
-    int ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_BACKGROUND);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_UTILITY);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEFAULT);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INITIATED);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEADLINE_REQUEST);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INTERACTIVE);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_SetThreadQoS(QoS_Level(-1));
-    EXPECT_EQ(ret, -1);
-    ret = OH_QoS_SetThreadQoS(QoS_Level(6));
-    EXPECT_EQ(ret, -1);
-    ret = OH_QoS_SetThreadQoS(QoS_Level(1024));
-    EXPECT_EQ(ret, -1);
-}
-
-HWTEST_F(QoSNdkTest, ResetThreadQoSNdkTest, TestSize.Level1)
-{
-    int ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_BACKGROUND);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_ResetThreadQoS();
-    EXPECT_EQ(ret, 0);
-
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_UTILITY);
-    EXPECT_EQ(ret, 0);
-    ret =  OH_QoS_ResetThreadQoS();
-    EXPECT_EQ(ret, 0);
-
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEFAULT);
-    EXPECT_EQ(ret, 0);
-    ret =  OH_QoS_ResetThreadQoS();
-    EXPECT_EQ(ret, 0);
-
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INITIATED);
-    EXPECT_EQ(ret, 0);
-    ret =  OH_QoS_ResetThreadQoS();
-    EXPECT_EQ(ret, 0);
-
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEADLINE_REQUEST);
-    EXPECT_EQ(ret, 0);
-    ret =  OH_QoS_ResetThreadQoS();
-    EXPECT_EQ(ret, 0);
-
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INTERACTIVE);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_ResetThreadQoS();
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QoSNdkTest, SetThreadQoSNdkTest0, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_BACKGROUND);
+    EXPECT_EQ(val, 0);
 }
 
-HWTEST_F(QoSNdkTest, GetThreadQoSNdkTest1, TestSize.Level1)
+HWTEST_F(QoSNdkTest, SetThreadQoSNdkTest1, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_UTILITY);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QoSNdkTest, SetThreadQoSNdkTest2, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEFAULT);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QoSNdkTest, SetThreadQoSNdkTest3, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INITIATED);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QoSNdkTest, SetThreadQoSNdkTest4, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEADLINE_REQUEST);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QoSNdkTest, SetThreadQoSNdkTest5, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INTERACTIVE);
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QoSNdkTest, SetThreadQoSNdkTestExt, TestSize.Level1)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level(-1));
+    EXPECT_EQ(val, -1);
+    val = OH_QoS_SetThreadQoS(QoS_Level(6));
+    EXPECT_EQ(val, -1);
+    val = OH_QoS_SetThreadQoS(QoS_Level(1024));
+    EXPECT_EQ(val, -1);
+}
+
+/**
+ * @tc.name: ResetThreadQoSNdkTest
+ * @tc.desc: Verify the Reset QoSLevel function.
+ * @tc.type: FUNC
+ */
+HWTEST_F(QoSNdkTest, ResetThreadQoSNdkTest0, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_BACKGROUND);
+    EXPECT_EQ(val, 0);
+    val = OH_QoS_ResetThreadQoS();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QoSNdkTest, ResetThreadQoSNdkTest1, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_UTILITY);
+    EXPECT_EQ(val, 0);
+    val = OH_QoS_ResetThreadQoS();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QoSNdkTest, ResetThreadQoSNdkTest2, TestSize.Level0)
 {
-    int ret = OH_QoS_GetThreadQoS(nullptr);
-    EXPECT_EQ(ret, -1);
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEFAULT);
+    EXPECT_EQ(val, 0);
+    val = OH_QoS_ResetThreadQoS();
+    EXPECT_EQ(val, 0);
+}
 
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_BACKGROUND);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QoSNdkTest, ResetThreadQoSNdkTest3, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INITIATED);
+    EXPECT_EQ(val, 0);
+    val = OH_QoS_ResetThreadQoS();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QoSNdkTest, ResetThreadQoSNdkTest4, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEADLINE_REQUEST);
+    EXPECT_EQ(val, 0);
+    val = OH_QoS_ResetThreadQoS();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QoSNdkTest, ResetThreadQoSNdkTest5, TestSize.Level0)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INTERACTIVE);
+    EXPECT_EQ(val, 0);
+    val = OH_QoS_ResetThreadQoS();
+    EXPECT_EQ(val, 0);
+}
+
+/**
+ * @tc.name: GetThreadQoSNdkTest
+ * @tc.desc: Verify the Get QoSLevel function.
+ * @tc.type: FUNC
+ */
+HWTEST_F(QoSNdkTest, GetThreadQoSNdkTest0, TestSize.Level1)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_BACKGROUND);
+    EXPECT_EQ(val, 0);
     enum QoS_Level level;
-    ret = OH_QoS_GetThreadQoS(&level);
-    EXPECT_EQ(ret, 0);
+    val = OH_QoS_GetThreadQoS(&level);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(level, QoS_Level::QOS_BACKGROUND);
+}
 
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_UTILITY);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_GetThreadQoS(&level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QoSNdkTest, GetThreadQoSNdkTest1, TestSize.Level1)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_UTILITY);
+    EXPECT_EQ(val, 0);
+    enum QoS_Level level;
+    val = OH_QoS_GetThreadQoS(&level);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(level, QoS_Level::QOS_UTILITY);
+}
 
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEFAULT);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_GetThreadQoS(&level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QoSNdkTest, GetThreadQoSNdkTest2, TestSize.Level1)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEFAULT);
+    EXPECT_EQ(val, 0);
+    enum QoS_Level level;
+    val = OH_QoS_GetThreadQoS(&level);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(level, QoS_Level::QOS_DEFAULT);
+}
 
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INITIATED);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_GetThreadQoS(&level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QoSNdkTest, GetThreadQoSNdkTest3, TestSize.Level1)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INITIATED);
+    EXPECT_EQ(val, 0);
+    enum QoS_Level level;
+    val = OH_QoS_GetThreadQoS(&level);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(level, QoS_Level::QOS_USER_INITIATED);
+}
 
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEADLINE_REQUEST);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_GetThreadQoS(&level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QoSNdkTest, GetThreadQoSNdkTest4, TestSize.Level1)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_DEADLINE_REQUEST);
+    EXPECT_EQ(val, 0);
+    enum QoS_Level level;
+    val = OH_QoS_GetThreadQoS(&level);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(level, QoS_Level::QOS_DEADLINE_REQUEST);
+}
 
-    ret = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INTERACTIVE);
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_GetThreadQoS(&level);
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QoSNdkTest, GetThreadQoSNdkTest5, TestSize.Level1)
+{
+    int val = OH_QoS_SetThreadQoS(QoS_Level::QOS_USER_INTERACTIVE);
+    EXPECT_EQ(val, 0);
+    enum QoS_Level level;
+    val = OH_QoS_GetThreadQoS(&level);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(level, QoS_Level::QOS_USER_INTERACTIVE);
+}
+
+HWTEST_F(QoSNdkTest, GetThreadQoSNdkTestExt, TestSize.Level1)
+{
+    int val = OH_QoS_GetThreadQoS(nullptr);
+    EXPECT_EQ(val, -1);
+    enum QoS_Level level;
 
-    ret = OH_QoS_ResetThreadQoS();
-    EXPECT_EQ(ret, 0);
-    ret = OH_QoS_GetThreadQoS(&level);
-    EXPECT_EQ(ret, -1);
+    val = OH_QoS_ResetThreadQoS();
+    EXPECT_EQ(val, 0);
+    val = OH_QoS_GetThreadQoS(&level);
+    EXPECT_EQ(val, -1);
 }
 } // QOS
 } // OHOS
\ No newline at end of file
diff --git a/test/unittest/phone/qos_test.cpp b/test/unittest/phone/qos_test.cpp
index 482c3c857ec8c9c164c6dc5c2fb1370b6bddb774..3d57c10be9d670dbef309f189ad6fee8fca1ad2c 100644
--- a/test/unittest/phone/qos_test.cpp
+++ b/test/unittest/phone/qos_test.cpp
@@ -49,253 +49,452 @@ void QosTest::TearDown()
 }
 
 /**
- * @tc.name: QosTest
- * @tc.desc: Verify the Set and Reset QosLevel function.
+ * @tc.name: SetThreadQosTest
+ * @tc.desc: Verify the Set QosLevel function.
  * @tc.type: FUNC
  */
-HWTEST_F(QosTest, SetThreadQosTest1, TestSize.Level1)
-{
-    int ret = SetThreadQos(QosLevel::QOS_USER_INITIATED);
-    EXPECT_EQ(ret, 0);
-    ret = SetThreadQos(QosLevel::QOS_DEFAULT);
-    EXPECT_EQ(ret, 0);
-    ret = SetThreadQos(QosLevel::QOS_UTILITY);
-    EXPECT_EQ(ret, 0);
-    ret = SetThreadQos(QosLevel::QOS_BACKGROUND);
-    EXPECT_EQ(ret, 0);
-    ret = SetThreadQos(QosLevel::QOS_DEADLINE_REQUEST);
-    EXPECT_EQ(ret, 0);
-    ret = SetThreadQos(QosLevel::QOS_USER_INTERACTIVE);
-    EXPECT_EQ(ret, 0);
-    ret = SetThreadQos(QosLevel::QOS_KEY_BACKGROUND);
-    EXPECT_EQ(ret, 0);
-    ret = SetThreadQos(QosLevel::QOS_MAX);
-    EXPECT_EQ(ret, -1);
-    ret = SetThreadQos(QosLevel(-1));
-    EXPECT_EQ(ret, -1);
-    ret = SetThreadQos(QosLevel(6));
-    EXPECT_EQ(ret, 0);
-    ret = SetThreadQos(QosLevel(1024));
-    EXPECT_EQ(ret, -1);
-}
-
-HWTEST_F(QosTest, SetThreadQosTest2, TestSize.Level1)
-{
-    int ret = SetQosForOtherThread(QosLevel::QOS_USER_INITIATED, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = SetQosForOtherThread(QosLevel::QOS_DEFAULT, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = SetQosForOtherThread(QosLevel::QOS_UTILITY, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = SetQosForOtherThread(QosLevel::QOS_BACKGROUND, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = SetQosForOtherThread(QosLevel::QOS_DEADLINE_REQUEST, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = SetQosForOtherThread(QosLevel::QOS_USER_INTERACTIVE, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = SetQosForOtherThread(QosLevel::QOS_KEY_BACKGROUND, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = SetQosForOtherThread(QosLevel::QOS_MAX, gettid());
-    EXPECT_EQ(ret, -1);
-    ret = SetQosForOtherThread(QosLevel(-1), gettid());
-    EXPECT_EQ(ret, -1);
-    ret = SetQosForOtherThread(QosLevel(6), gettid());
-    EXPECT_EQ(ret, 0);
-    ret = SetQosForOtherThread(QosLevel(1024), gettid());
-    EXPECT_EQ(ret, -1);
-}
-
-HWTEST_F(QosTest, ResetThreadQosTest1, TestSize.Level1)
-{
-    int ret = SetThreadQos(QosLevel::QOS_USER_INITIATED);
-    EXPECT_EQ(ret, 0);
-    ret = ResetThreadQos();
-    EXPECT_EQ(ret, 0);
-
-    ret = SetThreadQos(QosLevel::QOS_DEFAULT);
-    EXPECT_EQ(ret, 0);
-    ret = ResetThreadQos();
-    EXPECT_EQ(ret, 0);
-
-    ret = SetThreadQos(QosLevel::QOS_UTILITY);
-    EXPECT_EQ(ret, 0);
-    ret = ResetThreadQos();
-    EXPECT_EQ(ret, 0);
-
-    ret = SetThreadQos(QosLevel::QOS_BACKGROUND);
-    EXPECT_EQ(ret, 0);
-    ret = ResetThreadQos();
-    EXPECT_EQ(ret, 0);
-
-    ret = SetThreadQos(QosLevel::QOS_DEADLINE_REQUEST);
-    EXPECT_EQ(ret, 0);
-    ret = ResetThreadQos();
-    EXPECT_EQ(ret, 0);
-
-    ret = SetThreadQos(QosLevel::QOS_USER_INTERACTIVE);
-    EXPECT_EQ(ret, 0);
-    ret = ResetThreadQos();
-    EXPECT_EQ(ret, 0);
-
-    ret = SetThreadQos(QosLevel::QOS_KEY_BACKGROUND);
-    EXPECT_EQ(ret, 0);
-    ret = ResetThreadQos();
-    EXPECT_EQ(ret, 0);
-
-    ret = SetThreadQos(QosLevel::QOS_MAX);
-    EXPECT_EQ(ret, -1);
-    ret = ResetThreadQos();
-    EXPECT_EQ(ret, -1);
-
-    ret = SetThreadQos(QosLevel(6));
-    EXPECT_EQ(ret, 0);
-    ret = ResetThreadQos();
-    EXPECT_EQ(ret, 0);
-}
-
-HWTEST_F(QosTest, ResetThreadQosTest2, TestSize.Level1)
-{
-    int ret = SetQosForOtherThread(QosLevel::QOS_USER_INITIATED, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = ResetQosForOtherThread(gettid());
-    EXPECT_EQ(ret, 0);
-
-    ret = SetQosForOtherThread(QosLevel::QOS_DEFAULT, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = ResetQosForOtherThread(gettid());
-    EXPECT_EQ(ret, 0);
-
-    ret = SetQosForOtherThread(QosLevel::QOS_UTILITY, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = ResetQosForOtherThread(gettid());
-    EXPECT_EQ(ret, 0);
-
-    ret = SetQosForOtherThread(QosLevel::QOS_BACKGROUND, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = ResetQosForOtherThread(gettid());
-    EXPECT_EQ(ret, 0);
-
-    ret = SetQosForOtherThread(QosLevel::QOS_DEADLINE_REQUEST, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = ResetQosForOtherThread(gettid());
-    EXPECT_EQ(ret, 0);
-
-    ret = SetQosForOtherThread(QosLevel::QOS_USER_INTERACTIVE, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = ResetQosForOtherThread(gettid());
-    EXPECT_EQ(ret, 0);
-
-    ret = SetQosForOtherThread(QosLevel::QOS_KEY_BACKGROUND, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = ResetQosForOtherThread(gettid());
-    EXPECT_EQ(ret, 0);
-
-    ret = SetQosForOtherThread(QosLevel::QOS_MAX, gettid());
-    EXPECT_EQ(ret, -1);
-    ret = ResetQosForOtherThread(gettid());
-    EXPECT_EQ(ret, -1);
-
-    ret = SetQosForOtherThread(QosLevel(6), gettid());
-    EXPECT_EQ(ret, 0);
-    ret = ResetQosForOtherThread(gettid());
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosTest, SetThreadQosTest0, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_BACKGROUND);
+    EXPECT_EQ(val, 0);
 }
 
-HWTEST_F(QosTest, GetThreadQosTest1, TestSize.Level1)
+HWTEST_F(QosTest, SetThreadQosTest1, TestSize.Level0)
 {
-    int ret = SetThreadQos(QosLevel::QOS_USER_INITIATED);
-    EXPECT_EQ(ret, 0);
-    enum QosLevel level;
-    ret = GetThreadQos(level);
-    EXPECT_EQ(ret, 0);
-    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_USER_INITIATED));
+    int val = SetThreadQos(QosLevel::QOS_UTILITY);
+    EXPECT_EQ(val, 0);
+}
 
-    ret = SetThreadQos(QosLevel::QOS_USER_INTERACTIVE);
-    EXPECT_EQ(ret, 0);
-    ret = GetThreadQos(level);
-    EXPECT_EQ(ret, 0);
-    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_USER_INTERACTIVE));
+HWTEST_F(QosTest, SetThreadQosTest2, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_DEFAULT);
+    EXPECT_EQ(val, 0);
+}
 
-    ret = SetThreadQos(QosLevel::QOS_DEFAULT);
-    EXPECT_EQ(ret, 0);
-    ret = GetThreadQos(level);
-    EXPECT_EQ(ret, 0);
-    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_DEFAULT));
+HWTEST_F(QosTest, SetThreadQosTest3, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_USER_INITIATED);
+    EXPECT_EQ(val, 0);
+}
 
-    ret = SetThreadQos(QosLevel::QOS_UTILITY);
-    EXPECT_EQ(ret, 0);
-    ret = GetThreadQos(level);
-    EXPECT_EQ(ret, 0);
-    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_UTILITY));
+HWTEST_F(QosTest, SetThreadQosTest4, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_DEADLINE_REQUEST);
+    EXPECT_EQ(val, 0);
+}
 
-    ret = SetThreadQos(QosLevel::QOS_BACKGROUND);
-    EXPECT_EQ(ret, 0);
-    ret = GetThreadQos(level);
-    EXPECT_EQ(ret, 0);
-    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_BACKGROUND));
+HWTEST_F(QosTest, SetThreadQosTest5, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_USER_INTERACTIVE);
+    EXPECT_EQ(val, 0);
+}
 
-    ret = SetThreadQos(QosLevel::QOS_DEADLINE_REQUEST);
-    EXPECT_EQ(ret, 0);
-    ret = GetThreadQos(level);
-    EXPECT_EQ(ret, 0);
-    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_DEADLINE_REQUEST));
+HWTEST_F(QosTest, SetThreadQosTest6, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_KEY_BACKGROUND);
+    EXPECT_EQ(val, 0);
+}
 
-    ret = SetThreadQos(QosLevel::QOS_KEY_BACKGROUND);
-    EXPECT_EQ(ret, 0);
-    ret = GetThreadQos(level);
-    EXPECT_EQ(ret, 0);
-    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_KEY_BACKGROUND));
+HWTEST_F(QosTest, SetThreadQosTest7, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_MAX);
+    EXPECT_EQ(val, -1);
+}
+
+HWTEST_F(QosTest, SetThreadQosTestExt, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel(-1));
+    EXPECT_EQ(val, -1);
+    val = SetThreadQos(QosLevel(6));
+    EXPECT_EQ(val, 0);
+    val = SetThreadQos(QosLevel(1024));
+    EXPECT_EQ(val, -1);
+}
+
+/**
+ * @tc.name: SetQosForOtherThreadTest
+ * @tc.desc: Verify the Set QosLevel For Other function.
+ * @tc.type: FUNC
+ */
+HWTEST_F(QosTest, SetQosForOtherThreadTest0, TestSize.Level0)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_BACKGROUND, gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, SetQosForOtherThreadTest1, TestSize.Level0)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_UTILITY, gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, SetQosForOtherThreadTest2, TestSize.Level0)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_DEFAULT, gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, SetQosForOtherThreadTest3, TestSize.Level0)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_USER_INITIATED, gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, SetQosForOtherThreadTest4, TestSize.Level0)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_DEADLINE_REQUEST, gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, SetQosForOtherThreadTest5, TestSize.Level0)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_USER_INTERACTIVE, gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, SetQosForOtherThreadTest6, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_KEY_BACKGROUND, gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, SetQosForOtherThreadTest7, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_MAX, gettid());
+    EXPECT_EQ(val, -1);
+}
+
+HWTEST_F(QosTest, SetQosForOtherThreadTestExt, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel(-1), gettid());
+    EXPECT_EQ(val, -1);
+    val = SetQosForOtherThread(QosLevel(6), gettid());
+    EXPECT_EQ(val, 0);
+    val = SetQosForOtherThread(QosLevel(1024), gettid());
+    EXPECT_EQ(val, -1);
+}
+
+/**
+ * @tc.name: ResetThreadQosTest
+ * @tc.desc: Verify the Reset QosLevel function.
+ * @tc.type: FUNC
+ */
+HWTEST_F(QosTest, ResetThreadQosTest0, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_BACKGROUND);
+    EXPECT_EQ(val, 0);
+    val = ResetThreadQos();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetThreadQosTest1, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_UTILITY);
+    EXPECT_EQ(val, 0);
+    val = ResetThreadQos();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetThreadQosTest2, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_DEFAULT);
+    EXPECT_EQ(val, 0);
+    val = ResetThreadQos();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetThreadQosTest3, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_USER_INITIATED);
+    EXPECT_EQ(val, 0);
+    val = ResetThreadQos();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetThreadQosTest4, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_DEADLINE_REQUEST);
+    EXPECT_EQ(val, 0);
+    val = ResetThreadQos();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetThreadQosTest5, TestSize.Level0)
+{
+    int val = SetThreadQos(QosLevel::QOS_USER_INTERACTIVE);
+    EXPECT_EQ(val, 0);
+    val = ResetThreadQos();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetThreadQosTest6, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_KEY_BACKGROUND);
+    EXPECT_EQ(val, 0);
+    val = ResetThreadQos();
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetThreadQosTest7, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_MAX);
+    EXPECT_EQ(val, -1);
+    val = ResetThreadQos();
+    EXPECT_EQ(val, -1);
+}
+
+HWTEST_F(QosTest, ResetThreadQosTestExt, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel(6));
+    EXPECT_EQ(val, 0);
+    val = ResetThreadQos();
+    EXPECT_EQ(val, 0);
+}
+
+/**
+ * @tc.name: ResetQosForOtherThreadTest
+ * @tc.desc: Verify the Reset QosLevel For Other function.
+ * @tc.type: FUNC
+ */
+HWTEST_F(QosTest, ResetQosForOtherThreadTest0, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_BACKGROUND, gettid());
+    EXPECT_EQ(val, 0);
+    val = ResetQosForOtherThread(gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetQosForOtherThreadTest1, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_UTILITY, gettid());
+    EXPECT_EQ(val, 0);
+    val = ResetQosForOtherThread(gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetQosForOtherThreadTest2, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_DEFAULT, gettid());
+    EXPECT_EQ(val, 0);
+    val = ResetQosForOtherThread(gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetQosForOtherThreadTest3, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_USER_INITIATED, gettid());
+    EXPECT_EQ(val, 0);
+    val = ResetQosForOtherThread(gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetQosForOtherThreadTest4, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_DEADLINE_REQUEST, gettid());
+    EXPECT_EQ(val, 0);
+    val = ResetQosForOtherThread(gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetQosForOtherThreadTest5, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_USER_INTERACTIVE, gettid());
+    EXPECT_EQ(val, 0);
+    val = ResetQosForOtherThread(gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetQosForOtherThreadTest6, TestSize.Level0)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_KEY_BACKGROUND, gettid());
+    EXPECT_EQ(val, 0);
+    val = ResetQosForOtherThread(gettid());
+    EXPECT_EQ(val, 0);
+}
+
+HWTEST_F(QosTest, ResetQosForOtherThreadTest7, TestSize.Level0)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_MAX, gettid());
+    EXPECT_EQ(val, -1);
+    val = ResetQosForOtherThread(gettid());
+    EXPECT_EQ(val, -1);
+}
+
+HWTEST_F(QosTest, ResetQosForOtherThreadTestExt, TestSize.Level0)
+{
+    int val = SetQosForOtherThread(QosLevel(6), gettid());
+    EXPECT_EQ(val, 0);
+    val = ResetQosForOtherThread(gettid());
+    EXPECT_EQ(val, 0);
+}
+
+/**
+ * @tc.name: GetThreadQosTest
+ * @tc.desc: Verify the Get QosLevel function.
+ * @tc.type: FUNC
+ */
+HWTEST_F(QosTest, GetThreadQosTest0, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_BACKGROUND);
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetThreadQos(level);
+    EXPECT_EQ(val, 0);
+    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_BACKGROUND));
+}
+
+HWTEST_F(QosTest, GetThreadQosTest1, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_UTILITY);
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetThreadQos(level);
+    EXPECT_EQ(val, 0);
+    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_UTILITY));
 }
 
 HWTEST_F(QosTest, GetThreadQosTest2, TestSize.Level1)
 {
-    int ret = ResetThreadQos();
-    EXPECT_EQ(ret, 0);
+    int val = SetThreadQos(QosLevel::QOS_DEFAULT);
+    EXPECT_EQ(val, 0);
     enum QosLevel level;
-    ret = GetThreadQos(level);
-    EXPECT_EQ(ret, -1);
+    val = GetThreadQos(level);
+    EXPECT_EQ(val, 0);
+    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_DEFAULT));
+}
 
-    ret = SetQosForOtherThread(QosLevel::QOS_USER_INITIATED, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = GetQosForOtherThread(level, gettid());
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosTest, GetThreadQosTest3, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_USER_INITIATED);
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetThreadQos(level);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_USER_INITIATED));
+}
 
-    ret = SetQosForOtherThread(QosLevel::QOS_USER_INTERACTIVE, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = GetQosForOtherThread(level, gettid());
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosTest, GetThreadQosTest4, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_DEADLINE_REQUEST);
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetThreadQos(level);
+    EXPECT_EQ(val, 0);
+    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_DEADLINE_REQUEST));
+}
+
+HWTEST_F(QosTest, GetThreadQosTest5, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_USER_INTERACTIVE);
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetThreadQos(level);
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_USER_INTERACTIVE));
+}
 
-    ret = SetQosForOtherThread(QosLevel::QOS_DEFAULT, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = GetQosForOtherThread(level, gettid());
-    EXPECT_EQ(ret, 0);
-    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_DEFAULT));
+HWTEST_F(QosTest, GetThreadQosTest6, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_KEY_BACKGROUND);
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetThreadQos(level);
+    EXPECT_EQ(val, 0);
+    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_KEY_BACKGROUND));
+}
 
-    ret = SetQosForOtherThread(QosLevel::QOS_UTILITY, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = GetQosForOtherThread(level, gettid());
-    EXPECT_EQ(ret, 0);
-    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_UTILITY));
+HWTEST_F(QosTest, GetThreadQosTestExt, TestSize.Level1)
+{
+    int val = SetThreadQos(QosLevel::QOS_MAX);
+    EXPECT_NE(val, 0);
+    enum QosLevel level;
+    val = GetThreadQos(level);
+    EXPECT_EQ(val, 0);
+    EXPECT_NE(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_MAX));
+}
 
-    ret = SetQosForOtherThread(QosLevel::QOS_BACKGROUND, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = GetQosForOtherThread(level, gettid());
-    EXPECT_EQ(ret, 0);
+/**
+ * @tc.name: GetQosForOtherThread
+ * @tc.desc: Verify the Get QosLevel For Other function.
+ * @tc.type: FUNC
+ */
+HWTEST_F(QosTest, GetQosForOtherThreadTest0, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_BACKGROUND, gettid());
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetQosForOtherThread(level, gettid());
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_BACKGROUND));
+}
+
+HWTEST_F(QosTest, GetQosForOtherThreadTest1, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_UTILITY, gettid());
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetQosForOtherThread(level, gettid());
+    EXPECT_EQ(val, 0);
+    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_UTILITY));
+}
+
+HWTEST_F(QosTest, GetQosForOtherThreadTest2, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_DEFAULT, gettid());
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetQosForOtherThread(level, gettid());
+    EXPECT_EQ(val, 0);
+    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_DEFAULT));
+}
+
+HWTEST_F(QosTest, GetQosForOtherThreadTest3, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_USER_INITIATED, gettid());
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetQosForOtherThread(level, gettid());
+    EXPECT_EQ(val, 0);
+    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_USER_INITIATED));
+}
 
-    ret = SetQosForOtherThread(QosLevel::QOS_DEADLINE_REQUEST, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = GetQosForOtherThread(level, gettid());
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosTest, GetQosForOtherThreadTest4, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_DEADLINE_REQUEST, gettid());
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetQosForOtherThread(level, gettid());
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_DEADLINE_REQUEST));
+}
 
-    ret = SetQosForOtherThread(QosLevel::QOS_KEY_BACKGROUND, gettid());
-    EXPECT_EQ(ret, 0);
-    ret = GetQosForOtherThread(level, gettid());
-    EXPECT_EQ(ret, 0);
+HWTEST_F(QosTest, GetQosForOtherThreadTest5, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_USER_INTERACTIVE, gettid());
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetQosForOtherThread(level, gettid());
+    EXPECT_EQ(val, 0);
+    EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_USER_INTERACTIVE));
+}
+
+HWTEST_F(QosTest, GetQosForOtherThreadTest6, TestSize.Level1)
+{
+    int val = SetQosForOtherThread(QosLevel::QOS_KEY_BACKGROUND, gettid());
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetQosForOtherThread(level, gettid());
+    EXPECT_EQ(val, 0);
     EXPECT_EQ(static_cast<unsigned int>(level), static_cast<unsigned int>(QosLevel::QOS_KEY_BACKGROUND));
 }
+
+HWTEST_F(QosTest, GetQosForOtherThreadTestExt, TestSize.Level1)
+{
+    int val = ResetThreadQos();
+    EXPECT_EQ(val, 0);
+    enum QosLevel level;
+    val = GetThreadQos(level);
+    EXPECT_EQ(val, -1);
+}
 } // QOS
 } // OHOS
\ No newline at end of file