add sensor js interface testcase

Signed-off-by: Nliuzixuan10 <liuzixuan10@huawei.com>

appexecfwk/bundle_standard/bundlemanager/actsbundlemanagertest/entry/src/main/js/test/ExampleJsunit.test.js

@@ -1685,19 +1685,19 @@ describe('ActsBundleManagerTest', function () {
      */
     it('getApplicationInfo_0700', 0, async function (done) {
         let installData = await demo.getBundleInstaller();
-        installData.install([PATH + BMSJSTEST2, PATH + BMSJSTEST3], {
-            userId: 0,
-            installFlag: 0,
-            isKeepData: false
-        }, async (err, data) => {
+        installData.install([PATH + BMSJSTEST2, PATH + BMSJSTEST3], installParam, async (err, data) => {
             expect(err.code).assertEqual(0);
             expect(data.status).assertEqual(0);
             expect(data.statusMessage).assertEqual('SUCCESS');
             getInfo();
         });
         async function getInfo() {
-            await demo.getApplicationInfo(NAME2, demo.BundleFlag.GET_APPLICATION_INFO_WITH_PERMISSION,
-                                            demo.BundleFlag.GET_BUNDLE_WITH_ABILITIES, (error, datainfo) => {
+            await demo.getApplicationInfo(NAME2, BundleFlag.GET_APPLICATION_INFO_WITH_PERMISSION, 0, (error, datainfo) => {
+                if (error) {
+                    console.info("getApplicationInfo error" + JSON.stringify(error))
+                    expect(error).assertFail()
+                }
+                console.info("getApplicationInfo success" + JSON.stringify(datainfo))
                 expect(typeof datainfo).assertEqual(OBJECT)
                 expect(datainfo.name).assertEqual(NAME2)
                 expect(datainfo.label).assertEqual("$string:app_name")
@@ -1712,11 +1712,7 @@ describe('ActsBundleManagerTest', function () {
                 expect(datainfo.labelId >= 0).assertTrue()
                 expect(datainfo.systemApp).assertEqual(true)
                 expect(datainfo.supportedModes).assertEqual(0)
-                installData.uninstall(NAME2, {
-                    userId: 0,
-                    installFlag: 0,
-                    isKeepData: false
-                }, (err, data) => {
+                installData.uninstall(NAME2, installParam, (err, data) => {
                     expect(err.code).assertEqual(0);
                     expect(data.status).assertEqual(0);
                     expect(data.statusMessage).assertEqual('SUCCESS');
@@ -2030,7 +2026,7 @@ describe('ActsBundleManagerTest', function () {
     it('getApplicationInfo_0900', 0, async function (done) {
         demo.getApplicationInfo(ERROR, BundleFlag.GET_APPLICATION_INFO_WITH_PERMISSION, 0, (error, datainfo) => {
             if (error) {
-                console.error("getApplicationInfo fail" + JSON.stringify(error));
+                console.info("getApplicationInfo fail" + JSON.stringify(error));
                 expect(error).assertEqual(1);
                 done()
                 return;
@@ -2740,47 +2736,50 @@ describe('ActsBundleManagerTest', function () {
      */
     it('install_0300', 0, async function (done) {
         let installData = await demo.getBundleInstaller()
-        installData.install([PATH + BMSJSTEST4, PATH + BMSJSTEST5, PATH + BMSJSTEST6], {
-            userId: 0,
-            installFlag: 0,
-            isKeepData: false
-        }, async (err, data) => {
-            expect(err.code).assertEqual(-1);
-            expect(data.status).assertEqual(3);
-            expect(data.statusMessage).assertEqual('STATUS_INSTALL_FAILURE_INVALID');
-            getInfo();
+        installData.install([PATH + BMSJSTEST4], installParam, async (err, data) => {
+            expect(err.code).assertEqual(0);
+            expect(data.statusMessage).assertEqual('SUCCESS');
+            installData.install([PATH + BMSJSTEST5], installParam, async (err, data) => {
+                expect(err.code).assertEqual(0);
+                expect(data.statusMessage).assertEqual('SUCCESS');
+                installData.install([PATH + BMSJSTEST6], installParam, async (err, data) => {
+                    expect(err.code).assertEqual(0);
+                    expect(data.statusMessage).assertEqual('SUCCESS');
+                    getInfo();
+                });
+            });
         });
         async function getInfo() {
-            var datainfo1 = await demo.getBundleInfo(NAME3, demo.BundleFlag.GET_BUNDLE_WITH_ABILITIES);
-            expect(datainfo1.name).assertEqual('');
-            expect(datainfo1.uid < UIDMINVALUE).assertTrue();
-            var datainfo2 = await demo.getBundleInfo(NAME4, demo.BundleFlag.GET_BUNDLE_WITH_ABILITIES);
-            expect(datainfo2.name).assertEqual('');
-            expect(datainfo2.uid < UIDMINVALUE).assertTrue();
-            var datainfo3 = await demo.getBundleInfo(NAME5, demo.BundleFlag.GET_BUNDLE_WITH_ABILITIES);
-            expect(datainfo3.name).assertEqual('');
-            expect(datainfo3.uid < UIDMINVALUE).assertTrue();
-            installData.uninstall(NAME3, {
-                userId: 0,
-                installFlag: 0,
-                isKeepData: false
-            }, (err, data) => {
-                installData.uninstall(NAME4, {
-                    userId: 0,
-                    installFlag: 0,
-                    isKeepData: false
-                }, (err, data) => {
-                    installData.uninstall(NAME5, {
-                        userId: 0,
-                        installFlag: 0,
-                        isKeepData: false
-                    }, (err, data) => {
+            await demo.getBundleInfo(NAME3, BundleFlag.GET_BUNDLE_WITH_ABILITIES).then(dataInfo1 => {
+                expect(dataInfo1.name).assertEqual(NAME3);
+            }).catch(errInfo => {
+                expect(errInfo).assertFail()
+            });
+            await demo.getBundleInfo(NAME4, BundleFlag.GET_BUNDLE_WITH_ABILITIES).then(dataInfo2 => {
+                expect(dataInfo2.name).assertEqual(NAME4);
+            }).catch(errInfo => {
+                expect(errInfo).assertFail()
+            });
+            await demo.getBundleInfo(NAME5, BundleFlag.GET_BUNDLE_WITH_ABILITIES).then(dataInfo3 => {
+                expect(dataInfo3.name).assertEqual(NAME5);
+            }).catch(errInfo => {
+                expect(errInfo).assertFail()
+            });
+            installData.uninstall(NAME3, installParam, (err, data) => {
+                console.info("uninstall----result1" + JSON.stringify(data))
+                expect(err.code).assertEqual(0);
+                expect(data.statusMessage).assertEqual('SUCCESS');
+                installData.uninstall(NAME4, installParam, (err, data) => {
+                    console.info("uninstall----result2" + JSON.stringify(data))
+                    expect(err.code).assertEqual(0);
+                    expect(data.statusMessage).assertEqual('SUCCESS');
+                    installData.uninstall(NAME5, installParam, (err, data) => {
+                        console.info("uninstall----result3" + JSON.stringify(data))
+                        expect(err.code).assertEqual(0);
+                        expect(data.statusMessage).assertEqual('SUCCESS');
                         done();
                     });
                 });
-                expect(err.code).assertEqual(-1);
-                expect(data.status).assertEqual(7);
-                expect(data.statusMessage).assertEqual('STATUS_UNINSTALL_FAILURE');
             });
         }
     })

appexecfwk/bundle_standard/bundlemanager/actsbundlemanageruninstall/entry/src/main/js/test/ExampleJsunit.test.js

@@ -67,9 +67,16 @@ describe('ActsBundleManagerUninstall', function () {
                 installFlag: 1,
                 isKeepData: false
             }, async (err, data) => {
-                var datainfo2 = await demo.getBundleInfo(NAME1, 1);
-                expect(datainfo2.name).assertEqual('');
-                done();
+                expect(err.code).assertEqual(0);
+                expect(data.statusMessage).assertEqual('SUCCESS');
+                await demo.getBundleInfo(NAME1, 1).then(datainfo => {
+                    expect(datainfo).assertFail()
+                    done();
+                }).catch(err => {
+                    expect(err).assertEqual(1)
+                    done()
+                });
+
             })
         });
     })
@@ -178,8 +185,8 @@ describe('ActsBundleManagerUninstall', function () {
             function OnReceiveinstallEvent(err, data) {
                 expect(typeof data).assertEqual(OBJECT);
                 expect(data.statusMessage).assertEqual("STATUS_UNINSTALL_FAILURE");
+                done();
             }
-            done();
         });
     })
 
@@ -242,16 +249,24 @@ describe('ActsBundleManagerUninstall', function () {
         async function OnReceiveinstallEvent(err, data) {
             expect(typeof data).assertEqual(OBJECT);
             expect(data.statusMessage).assertEqual(SUCCESS);
-            var datainfo1 = await demo.getBundleInfo(NAME1, 1);
-            expect(datainfo1.name).assertEqual(NAME1);
+            await demo.getBundleInfo(NAME1, 1).then(datainfo1 => {
+                expect(datainfo1.name).assertEqual(NAME1);
+            }).catch(err => {
+                expect(err).assertFail();
+            });
             result.uninstall(NAME1, {
                 userId: 0,
                 installFlag: 1,
                 isKeepData: false
             }, async(err, data) => {
-                var datainfo2 = await demo.getBundleInfo(NAME1, 1);
-                expect(datainfo2.name).assertEqual('');
-                done();
+                expect(data.statusMessage).assertEqual(SUCCESS);
+                await demo.getBundleInfo(NAME1, 1).then(datainfo2 => {
+                    expect(datainfo2).assertFail();
+                    done();
+                }).catch(err => {
+                    expect(err).assertEqual(1);
+                    done();
+                });
             });
         }
     })

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_acc_uncal.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_ACCELEROMETER_UNCALIBRATED, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_ACCELEROMETER_UNCALIBRATED, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " 
+                        + data.z + "biasX:" + data.biasX + "biasY: " + data.biasY + "biasZ: " + data.biasZ);
+                    expect(typeof (data.x)).assertEqual("number");
+                    expect(typeof (data.y)).assertEqual("number");
+                    expect(typeof (data.z)).assertEqual("number");
+                    expect(typeof (data.biasX)).assertEqual("number");
+                    expect(typeof (data.biasY)).assertEqual("number");
+                    expect(typeof (data.biasZ)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " 
+                    + data.z + "biasX:" + data.biasX + "biasY: " + data.biasY + "biasZ: " + data.biasZ);
+                expect(typeof (data.x)).assertEqual("number");
+                expect(typeof (data.y)).assertEqual("number");
+                expect(typeof (data.z)).assertEqual("number");
+                expect(typeof (data.biasX)).assertEqual("number");
+                expect(typeof (data.biasY)).assertEqual("number");
+                expect(typeof (data.biasZ)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_ACCELEROMETER_UNCALIBRATED, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_bar.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_BAROMETER, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_BAROMETER, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on success pressure: ' + data.pressure);
+                    expect(typeof (data.pressure)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success pressure: ' + data.pressure);
+                expect(typeof (data.pressure)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_BAROMETER, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_dete.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_WEAR_DETECTION, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_WEAR_DETECTION, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  once success value: ' + data.value);
+                    expect(typeof (data.value)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success value: ' + data.value);
+                expect(typeof (data.value)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_WEAR_DETECTION, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_field_unca.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_MAGNETIC_FIELD_UNCALIBRATED, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_MAGNETIC_FIELD_UNCALIBRATED, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " 
+                        + data.z + "biasX:" + data.biasX + "biasY: " + data.biasY + "biasZ: " + data.biasZ);
+                    expect(typeof (data.x)).assertEqual("number");
+                    expect(typeof (data.y)).assertEqual("number");
+                    expect(typeof (data.z)).assertEqual("number");
+                    expect(typeof (data.biasX)).assertEqual("number");
+                    expect(typeof (data.biasY)).assertEqual("number");
+                    expect(typeof (data.biasZ)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " 
+                    + data.z + "biasX:" + data.biasX + "biasY: " + data.biasY + "biasZ: " + data.biasZ);
+                expect(typeof (data.x)).assertEqual("number");
+                expect(typeof (data.y)).assertEqual("number");
+                expect(typeof (data.z)).assertEqual("number");
+                expect(typeof (data.biasX)).assertEqual("number");
+                expect(typeof (data.biasY)).assertEqual("number");
+                expect(typeof (data.biasZ)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_MAGNETIC_FIELD_UNCALIBRATED, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_grav.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_GRAVITY, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_GRAVITY, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " + data.z);
+                    expect(typeof (data.x)).assertEqual("number");
+                    expect(typeof (data.y)).assertEqual("number");
+                    expect(typeof (data.z)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " + data.z);
+                expect(typeof (data.x)).assertEqual("number");
+                expect(typeof (data.y)).assertEqual("number");
+                expect(typeof (data.z)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_GRAVITY, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_gyr_unca.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_GYROSCOPE_UNCALIBRATED, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_GYROSCOPE_UNCALIBRATED, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " 
+                        + data.z + "biasX:" + data.biasX + "biasY: " + data.biasY + "biasZ: " + data.biasZ);
+                    expect(typeof (data.x)).assertEqual("number");
+                    expect(typeof (data.y)).assertEqual("number");
+                    expect(typeof (data.z)).assertEqual("number");
+                    expect(typeof (data.biasX)).assertEqual("number");
+                    expect(typeof (data.biasY)).assertEqual("number");
+                    expect(typeof (data.biasZ)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " 
+                    + data.z + "biasX:" + data.biasX + "biasY: " + data.biasY + "biasZ: " + data.biasZ);
+                expect(typeof (data.x)).assertEqual("number");
+                expect(typeof (data.y)).assertEqual("number");
+                expect(typeof (data.z)).assertEqual("number");
+                expect(typeof (data.biasX)).assertEqual("number");
+                expect(typeof (data.biasY)).assertEqual("number");
+                expect(typeof (data.biasZ)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_GYROSCOPE_UNCALIBRATED, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_harr.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_HALL, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_HALL, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on success status: ' + data.status);
+                    expect(typeof (data.status)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success status: ' + data.status);
+                expect(typeof (data.status)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_HALL, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_humi.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_HUMIDITY, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_HUMIDITY, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on success humidity: ' + data.humidity);
+                    expect(typeof (data.humidity)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success humidity: ' + data.humidity);
+                expect(typeof (data.humidity)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_HUMIDITY, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_line_acc.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_LINEAR_ACCELERATION, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_LINEAR_ACCELERATION, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " + data.z);
+                    expect(typeof (data.x)).assertEqual("number");
+                    expect(typeof (data.y)).assertEqual("number");
+                    expect(typeof (data.z)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " + data.z);
+                expect(typeof (data.x)).assertEqual("number");
+                expect(typeof (data.y)).assertEqual("number");
+                expect(typeof (data.z)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_LINEAR_ACCELERATION, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_moti.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_SIGNIFICANT_MOTION, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_SIGNIFICANT_MOTION, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  once success scalar: ' + data.scalar);
+                    expect(typeof (data.scalar)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success scalar: ' + data.scalar);
+                expect(typeof (data.scalar)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_SIGNIFICANT_MOTION, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_orie.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_ORIENTATION, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_ORIENTATION, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " + data.z);
+                    expect(typeof (data.x)).assertEqual("number");
+                    expect(typeof (data.y)).assertEqual("number");
+                    expect(typeof (data.z)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest001  once  success, x: ' + data.x + "y: " + data.y + "z: " + data.z);
+                expect(typeof (data.x)).assertEqual("number");
+                expect(typeof (data.y)).assertEqual("number");
+                expect(typeof (data.z)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_ORIENTATION, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_ped.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_PEDOMETER, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_PEDOMETER, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  once success steps: ' + data.steps);
+                    expect(typeof (data.steps)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success steps: ' + data.steps);
+                expect(typeof (data.steps)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_PEDOMETER, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_ped_det.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_PEDOMETER_DETECTION, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_PEDOMETER_DETECTION, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  once success scalar: ' + data.scalar);
+                    expect(typeof (data.scalar)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success scalar: ' + data.scalar);
+                expect(typeof (data.scalar)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_PEDOMETER_DETECTION, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_prox.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_PROXIMITY, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_PROXIMITY, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on success distance: ' + data.distance);
+                    expect(typeof (data.distance)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success distance: ' + data.distance);
+                expect(typeof (data.distance)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_PROXIMITY, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_rate.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_HEART_RATE, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_HEART_RATE, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  once success heartRate: ' + data.heartRate);
+                    expect(typeof (data.heartRate)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success heartRate: ' + data.heartRate);
+                expect(typeof (data.heartRate)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_HEART_RATE, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_temp.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_AMBIENT_TEMPERATURE, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_AMBIENT_TEMPERATURE, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  once success temperature: ' + data.temperature);
+                    expect(typeof (data.temperature)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest005  once success temperature: ' + data.temperature);
+                expect(typeof (data.temperature)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_AMBIENT_TEMPERATURE, onceSensorCallback);
+    })
+})

sensors/sensor_standard/src/main/js/default/test/SensorOnOffTest.test_vec.js

+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import sensor from '@ohos.sensor'
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
+
+describe("SensorJsTest", function () {
+    beforeAll(function () {
+
+        /*
+         * @tc.setup: setup invoked before all testcases
+         */
+        console.info('beforeAll caled')
+    })
+
+    afterAll(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after all testcases
+         */
+        console.info('afterAll caled')
+    })
+
+    beforeEach(function () {
+
+        /*
+         * @tc.setup: setup invoked before each testcases
+         */
+        console.info('beforeEach caled')
+    })
+
+    afterEach(function () {
+
+        /*
+         * @tc.teardown: teardown invoked after each testcases
+         */
+        console.info('afterEach caled')
+    })
+
+    /*
+     * @tc.name:SensorJsTest001
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest001", 0, async function (done) {
+        console.info('----------------------SensorJsTest001---------------------------');
+        function offPromise() {
+            return new Promise((resolve, reject) => {
+                sensor.off(sensor.SensorType.SENSOR_TYPE_ID_ROTATION_VECTOR, (error) => {
+                    if (error) {
+                        console.info('SensorJsTest001  off error');
+                        expect(false).assertTrue();
+                        console.info('setTimeout ..start')
+                        setTimeout((err) => {
+                            reject(err);
+                        }, 500);
+                    } else {
+                        console.info('SensorJsTest001  off success');
+                        expect(true).assertTrue();
+                        setTimeout(() => {
+                            resolve();
+                        }, 500);
+                    }
+                }, 1000)
+            })
+        }
+
+        let promise = new Promise((resolve, reject) => {
+            sensor.on(sensor.SensorType.SENSOR_TYPE_ID_ROTATION_VECTOR, function (error, data) {
+                if (error) {
+                    console.info('SensorJsTest001  on error');
+                    expect(false).assertTrue();
+                    setTimeout((err) => {
+                        reject(err);
+                    }, 500);
+                } else {
+                    console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " + data.z);
+                    expect(typeof (data.x)).assertEqual("number");
+                    expect(typeof (data.y)).assertEqual("number");
+                    expect(typeof (data.z)).assertEqual("number");
+                    setTimeout(() => {
+                        resolve();
+                    }, 500);
+                }
+            });
+        })
+
+        await promise.then(() => {
+            return offPromise();
+        }, () => {
+            console.info("SensorJsTest001 reject");
+        })
+        done();
+    })
+
+    /*
+     * @tc.name:SensorJsTest005
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SensorJsTest005", 0, async function (done) {
+        function onceSensorCallback(error, data) {
+            if (error) {
+                console.info('SensorJsTest005  once error');
+                expect(false).assertTrue();
+            } else {
+                console.info('SensorJsTest001  on  success, x: ' + data.x + "y: " + data.y + "z: " + data.z);
+                expect(typeof (data.x)).assertEqual("number");
+                expect(typeof (data.y)).assertEqual("number");
+                expect(typeof (data.z)).assertEqual("number");
+            }
+            setTimeout(() => {
+                done();
+            }, 500);
+        }
+        sensor.once(sensor.SensorType.SENSOR_TYPE_ID_ROTATION_VECTOR, onceSensorCallback);
+    })
+})