!1577 add sensor js interface testcase

Merge pull request !1577 from liuzixuan10/master

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);
+    })
+})