diff --git a/interfaces/plugin/src/sensor_js.cpp b/interfaces/plugin/src/sensor_js.cpp
index a3d9c68afcbb1e82dfc729ed8c8572935f56b612..56f2464932b9ae6c470d74c1c762e0ff0411434e 100644
--- a/interfaces/plugin/src/sensor_js.cpp
+++ b/interfaces/plugin/src/sensor_js.cpp
@@ -881,9 +881,10 @@ napi_value Subscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId
     sptr<AsyncCallbackInfo> asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env, type);
     CHKPP(asyncCallbackInfo);
     napi_value napiSuccess = GetNamedProperty(env, args[0], "success");
+    CHKNCP(env, (napiSuccess != nullptr), "get napiSuccess fail");
     CHKNCP(env, RegisterNapiCallback(env, napiSuccess, asyncCallbackInfo->callback[0]),
         "register callback fail");
-    napi_value napiFail = GetNamedProperty(env, args[0], "success");
+    napi_value napiFail = GetNamedProperty(env, args[0], "fail");
     if (napiFail != nullptr) {
         SEN_HILOGD("has fail callback");
         CHKNCP(env, RegisterNapiCallback(env, napiFail, asyncCallbackInfo->callback[1]),
diff --git a/interfaces/plugin/src/sensor_napi_utils.cpp b/interfaces/plugin/src/sensor_napi_utils.cpp
index a8a761442a48833868e7c972bf4c65a96027ef02..54960163a6d6c18b6c083f420b9530346fc8d81f 100644
--- a/interfaces/plugin/src/sensor_napi_utils.cpp
+++ b/interfaces/plugin/src/sensor_napi_utils.cpp
@@ -67,6 +67,12 @@ bool GetFloatArray(const napi_env &env, const napi_value &value, vector<float> &
 napi_value GetNamedProperty(const napi_env &env, const napi_value &object, string name)
 {
     CALL_LOG_ENTER;
+    bool status = false;
+    CHKNRP(env, napi_has_named_property(env, object, name.c_str(), &status), "napi_has_named_property");
+    if (!status) {
+        SEN_HILOGW("%{public}s not exists on the object", name.c_str());
+        return nullptr;
+    }
     napi_value value = nullptr;
     CHKNRP(env, napi_get_named_property(env, object, name.c_str(), &value),
         "napi_get_named_property");
diff --git a/interfaces/plugin/test/ExampleJsunit.test_system.js b/interfaces/plugin/test/ExampleJsunit.test_system.js
index 17233466ba5d702f026eaf3f5745dd5e520d1225..a966ce2f51033e2b88ba26041cdbd69b219bcd7d 100644
--- a/interfaces/plugin/test/ExampleJsunit.test_system.js
+++ b/interfaces/plugin/test/ExampleJsunit.test_system.js
@@ -49,7 +49,7 @@ describe("SensorJsTest", function () {
      * @tc.name:SensorJsTest001
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
     it("SensorJsTest001", 0, async function (done) {
         console.info('----------------------SensorJsTest001---------------------------');
@@ -59,321 +59,448 @@ describe("SensorJsTest", function () {
               expect(typeof(data.x)).assertEqual("number");
               expect(typeof(data.y)).assertEqual("number");
               expect(typeof(data.z)).assertEqual("number");
-              console.info("callback2" + JSON.stringify(data));
-              done();
+              console.info("SensorJsTest001 success" + JSON.stringify(data));
             },
             fail: function(data, code) {
               expect(false).assertTrue();
               console.error('Subscription failed. Code: ' + code + '; Data: ' + data);
-              done();
             },
-          });
+        });
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeAccelerometer();
+            } catch (error) {
+                console.info('SensorJsTest001 unsubscribe failed' + error);
+                expect(false).assertTrue();
+            }
+            setTimeout(()=>{
+                expect(true).assertTrue();
+                done();
+            }, 500);
+        }, 1000);
     })
 
     /*
      * @tc.name:SensorJsTest002
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
     it("SensorJsTest002", 0, async function (done) {
         console.info('----------------------SensorJsTest002---------------------------');
-        try {
-            sensor.unsubscribeAccelerometer();
-        } catch (error) {
-            console.info(error);
-            expect(false).assertTrue();
-            done();
-        }
-        expect(true).assertTrue();
+        sensor.subscribeAccelerometer({
+            interval: 'xxx',
+            success: function(data) {
+              expect(false).assertTrue();
+              console.info("SensorJsTest002 success" + JSON.stringify(data));
+              done();
+            },
+            fail: function(data, code) {
+              expect(true).assertTrue();
+              console.error('SensorJsTest002 Subscription failed. Code: ' + code + '; Data: ' + data);
+              done();
+            },
+          });
     })
 
     /*
      * @tc.name:SensorJsTest003
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
     it("SensorJsTest003", 0, async function (done) {
         console.info('----------------------SensorJsTest003---------------------------');
-        sensor.subscribeCompass({
-            success: function(data) {
-               console.log('get data direction:' + ret.direction);
-               expect(typeof(data.direction)).assertEqual("number");
-               done();
-            },
-            fail: function(data, code) {
-                console.info(error);
-                expect(false).assertTrue();
-                done();
-            },
-          });
+        try {
+            sensor.subscribeAccelerometer({
+                interval: 'xxx',
+                success: function(data) {
+                  expect(false).assertTrue();
+                  console.info("SensorJsTest003 success" + JSON.stringify(data));
+                  done();
+                }
+              });
+        } catch (error) {
+            console.info('SensorJsTest003 Subscription failed' + error);
+            expect(true).assertTrue();
+            done();
+        }
     })
 
     /*
      * @tc.name:SensorJsTest004
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
-    it("SensorJsTest004", 0, function (done) {
+    it("SensorJsTest004", 0, async function (done) {
         console.info('----------------------SensorJsTest004---------------------------');
         try {
-            sensor.unsubscribeCompass();
+            sensor.subscribeAccelerometer({
+                interval: 'normal',
+            });
         } catch (error) {
-            console.info(error);
-            expect(false).assertTrue();
+            console.info('SensorJsTest004 Subscription failed' + error);
+            expect(true).assertTrue();
             done();
         }
-        expect(true).assertTrue();
     })
 
     /*
      * @tc.name:SensorJsTest005
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
     it("SensorJsTest005", 0, async function (done) {
-        sensor.subscribeProximity({
-            success: function(data) {
-                expect(typeof(data.distance)).assertEqual("number");
-                console.info("subscribeProximity" + JSON.stringify(data));
-                done();
-            },
-            fail: function(data, code) {
-                console.info(error);
-                expect(false).assertTrue();
-                done();
-            },
-          });
+        console.info('----------------------SensorJsTest005---------------------------');
+        try {
+            sensor.unsubscribeAccelerometer();
+        } catch (error) {
+            console.info(error);
+            expect(true).assertTrue();
+            done();
+        }
     })
 
     /*
      * @tc.name:SensorJsTest006
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
     it("SensorJsTest006", 0, async function (done) {
+        console.info('----------------------SensorJsTest006---------------------------');
         try {
-            sensor.unsubscribeProximity();
+            sensor.unsubscribeAccelerometer('xxx');
         } catch (error) {
             console.info(error);
-            expect(false).assertTrue();
+            expect(true).assertTrue();
             done();
         }
-        expect(true).assertTrue();
     })
 
     /*
      * @tc.name:SensorJsTest007
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
-    it("SensorJsTest007", 0, function (done) {
-        sensor.subscribeLight({
+    it("SensorJsTest007", 0, async function (done) {
+        console.info('----------------------SensorJsTest007---------------------------');
+        sensor.subscribeCompass({
             success: function(data) {
-                expect(typeof(data.intensity)).assertEqual("number");
-                console.info("subscribeLight" + JSON.stringify(data));
-                done();
+               console.log('SensorJsTest007 get data direction:' + ret.direction);
+               expect(typeof(data.direction)).assertEqual("number");
             },
             fail: function(data, code) {
+                console.error('SensorJsTest007 Subscription failed. Code: ' + code + '; Data: ' + data);
+                expect(false).assertTrue();
+            },
+        });
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeCompass();
+            } catch (error) {
                 console.info(error);
                 expect(false).assertTrue();
+            }
+            setTimeout(()=>{
+                expect(true).assertTrue();
                 done();
-            },
-          });
+            }, 500);
+        }, 1000);
     })
 
     /*
      * @tc.name:SensorJsTest008
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
     it("SensorJsTest008", 0, async function (done) {
-        try {
-            sensor.unsubscribeLight();
-        } catch (error) {
-            console.info(error);
-            expect(false).assertTrue();
-            done();
-        }
-        expect(true).assertTrue();
+        sensor.subscribeProximity({
+            success: function(data) {
+                expect(typeof(data.distance)).assertEqual("number");
+                console.info("SensorJsTest008 subscribeProximity" + JSON.stringify(data));
+            },
+            fail: function(data, code) {
+                console.error('SensorJsTest008 Subscription failed. Code: ' + code + '; Data: ' + data);
+                expect(true).assertTrue();
+            },
+          });
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeProximity();
+            } catch (error) {
+                console.info(error);
+            }
+            setTimeout(()=>{
+                expect(true).assertTrue();
+                done();
+            }, 500);
+        }, 1000);
     })
 
     /*
      * @tc.name:SensorJsTest009
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
-    it("SensorJsTest009", 0, async function (done) {
-        sensor.subscribeStepCounter({
+    it("SensorJsTest009", 0, function (done) {
+        sensor.subscribeLight({
             success: function(data) {
-                expect(typeof(data.steps)).assertEqual("number");
-                console.info("subscribeStepCounter" + JSON.stringify(data));
-                done();
+                expect(typeof(data.intensity)).assertEqual("number");
+                console.info("SensorJsTest009 subscribeLight" + JSON.stringify(data));
             },
             fail: function(data, code) {
-                console.info(error);
+                console.error('SensorJsTest009 Subscription failed. Code: ' + code + '; Data: ' + data);
                 expect(false).assertTrue();
-                done();
             },
           });
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeLight();
+            } catch (error) {
+                console.info(error);
+                expect(false).assertTrue();
+            }
+            setTimeout(()=>{
+                expect(true).assertTrue();
+                done();
+            }, 500);
+        }, 1000);
     })
 
     /*
      * @tc.name:SensorJsTest010
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
     it("SensorJsTest010", 0, async function (done) {
-        try {
-            sensor.unsubscribeStepCounter();
-        } catch (error) {
-            console.info(error);
-            expect(false).assertTrue();
-            done();
-        }
-        expect(true).assertTrue();
+        sensor.subscribeStepCounter({
+            success: function(data) {
+                expect(typeof(data.steps)).assertEqual("number");
+                console.info("SensorJsTest010 subscribeStepCounter" + JSON.stringify(data));
+            },
+            fail: function(data, code) {
+                console.error('SensorJsTest010 Subscription failed. Code: ' + code + '; Data: ' + data);
+                expect(true).assertTrue();
+            },
+          });
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeStepCounter();
+            } catch (error) {
+                console.info(error);
+            }
+            setTimeout(()=>{
+                expect(true).assertTrue();
+                done();
+            }, 500);
+        }, 1000);
     })
 
     /*
      * @tc.name:SensorJsTest011
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
     it("SensorJsTest011", 0, async function (done) {
         sensor.subscribeBarometer({
             success: function(data) {
                 expect(typeof(data.pressure)).assertEqual("number");
                 console.info("subscribeBarometer" + JSON.stringify(data));
-                done();
             },
             fail: function(data, code) {
-                console.info(error);
-                expect(false).assertTrue();
-                done();
+                console.error('SensorJsTest011 Subscription failed. Code: ' + code + '; Data: ' + data);
+                expect(true).assertTrue();
             },
           });
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeBarometer();
+            } catch (error) {
+                console.info(error);
+            }
+            setTimeout(()=>{
+                expect(true).assertTrue();
+                done();
+            }, 500);
+        }, 1000);
     })
 
     /*
      * @tc.name:SensorJsTest012
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
-    it("SensorJsTest012", 0, async function (done) {
-        try {
-            sensor.unsubscribeBarometer();
-        } catch (error) {
-            console.info(error);
-            expect(false).assertTrue();
-            done();
-        }
-        expect(true).assertTrue();
+    it("SensorJsTest012", 0, function (done) {
+        sensor.subscribeHeartRate({
+            success: function(data) {
+                expect(typeof(data.heartRate)).assertEqual("number");
+                console.info("SensorJsTest012 subscribeHeartRate" + JSON.stringify(data));
+            },
+            fail: function(data, code) {
+                console.error('SensorJsTest012 Subscription failed. Code: ' + code + '; Data: ' + data);
+                expect(true).assertTrue();
+            },
+          });
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeHeartRate();
+            } catch (error) {
+                console.info(error);
+            }
+            setTimeout(()=>{
+                expect(true).assertTrue();
+                done();
+            }, 500);
+        }, 1000);
     })
 
     /*
      * @tc.name:SensorJsTest013
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
-    it("SensorJsTest013", 0, function (done) {
-        sensor.subscribeHeartRate({
+    it("SensorJsTest013", 0, async function (done) {
+        console.info('----------------------SensorJsTest013---------------------------');
+        sensor.subscribeOnBodyState({
             success: function(data) {
-                expect(typeof(data.heartRate)).assertEqual("number");
-                console.info("subscribeHeartRate" + JSON.stringify(data));
-                done();
+                expect(typeof(data.value)).assertEqual("number");
+                console.info("SensorJsTest013 subscribeOnBodyState" + JSON.stringify(data));
             },
             fail: function(data, code) {
-                console.info(error);
-                expect(false).assertTrue();
-                done();
+                console.error('SensorJsTest013 Subscription failed. Code: ' + code + '; Data: ' + data);
+                expect(true).assertTrue();
             },
           });
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeOnBodyState();
+            } catch (error) {
+                console.info(error);
+            }
+            setTimeout(()=>{
+                expect(true).assertTrue();
+                done();
+            }, 500);
+        }, 1000);
     })
 
     /*
      * @tc.name:SensorJsTest014
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
-    it("SensorJsTest014", 0, async function (done) {
+      it('SensorJsTest014', 0, async function (done) {
+        console.info("---------------------------SensorJsTest014----------------------------------");
         try {
-            sensor.unsubscribeHeartRate();
+            sensor.getOnBodyState({
+                success: function(data) {
+                    expect(typeof(data.value)).assertEqual("boolean");
+                    console.info("subscribeOnBodyState" + JSON.stringify(data));
+                    done();
+                }
+            });
         } catch (error) {
             console.info(error);
             expect(false).assertTrue();
             done();
         }
-        expect(true).assertTrue();
     })
 
     /*
      * @tc.name:SensorJsTest015
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
-    it("SensorJsTest015", 0, async function (done) {
-        console.info('----------------------SensorJsTest015---------------------------');
-        sensor.subscribeOnBodyState({
+    it('SensorJsTest015', 0, async function (done) {
+        console.info("---------------------------SensorJsTest014----------------------------------");
+        try {
+            sensor.getOnBodyState();
+        } catch (error) {
+            console.info(error);
+            expect(true).assertTrue();
+            done();
+        }
+    })
+
+    /*
+     * @tc.name:SensorJsTest016
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: SR000H0ALK, AR000H0ALM
+     */
+    it("SensorJsTest016", 0, async function (done) {
+        console.info('----------------------SensorJsTest016---------------------------');
+        sensor.subscribeDeviceOrientation({
+            interval: 'normal',
             success: function(data) {
-                expect(typeof(data.value)).assertEqual("number");
-                console.info("subscribeOnBodyState" + JSON.stringify(data));
-                done();
+                expect(typeof(data.alpha)).assertEqual("number");
+                expect(typeof(data.beta)).assertEqual("number");
+                expect(typeof(data.gamma)).assertEqual("number");
+                console.info("SensorJsTest016 subscribeDeviceOrientation" + JSON.stringify(data));
             },
             fail: function(data, code) {
-                console.info(error);
+                console.error('SensorJsTest015 Subscription failed. Code: ' + code + '; Data: ' + data);
                 expect(false).assertTrue();
-                done();
             },
           });
-    })
-
-     /**
-     * test
-     *
-     * @tc.name: SensorJsTest_016
-     * @tc.desc: Verification results of the incorrect parameters of the test interface.
-     * @tc.require: AR000GH2U6
-     * @tc.author:
-     */
-      it('SensorJsTest016', 0, async function (done) {
-        console.info("---------------------------SensorJsTest016----------------------------------");
-        sensor.getOnBodyState({
-            success: function(data) {
-                expect(typeof(data.value)).assertEqual("number");
-                console.info("subscribeOnBodyState" + JSON.stringify(data));
-                done();
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeDeviceOrientation();
+            } catch (error) {
+                console.info(error);
+                expect(false).assertTrue();
             }
-          });
+            setTimeout(()=>{
+                expect(true).assertTrue();
+                done();
+            }, 500);
+        }, 1000);
     })
 
     /*
      * @tc.name:SensorJsTest017
      * @tc.desc:verify app info is not null
      * @tc.type: FUNC
-     * @tc.require: Issue Number
+     * @tc.require: SR000H0ALK, AR000H0ALM
      */
     it("SensorJsTest017", 0, async function (done) {
         console.info('----------------------SensorJsTest017---------------------------');
-        try {
-            sensor.unsubscribeOnBodyState();
-        } catch (error) {
-            console.info(error);
-            expect(false).assertTrue();
-            done();
-        }
-        expect(true).assertTrue();
+        sensor.subscribeGyroscope({
+            interval: 'normal',
+            success: function(data) {
+                expect(typeof(data.x)).assertEqual("number");
+                expect(typeof(data.y)).assertEqual("number");
+                expect(typeof(data.z)).assertEqual("number");
+                console.info("SensorJsTest017 subscribeGyroscope" + JSON.stringify(data));
+            },
+            fail: function(data, code) {
+                console.error('SensorJsTest017 Subscription failed. Code: ' + code + '; Data: ' + data);
+                expect(false).assertTrue();
+            },
+          });
+        setTimeout(()=>{
+            try {
+                sensor.unsubscribeGyroscope();
+            } catch (error) {
+                console.info(error);
+                expect(false).assertTrue();
+            }
+            setTimeout(()=>{
+                expect(true).assertTrue();
+                done();
+            }, 500);
+        }, 1000);
     })
 })