diff --git a/sensors/sensor_standard/src/main/js/default/test/List.test.js b/sensors/sensor_standard/src/main/js/default/test/List.test.js
index 988585d79106649446b547c85d1bc1705189af8b..ee12a3b1e2e14761b95de0bc2c21f0067fb7d7cb 100644
--- a/sensors/sensor_standard/src/main/js/default/test/List.test.js
+++ b/sensors/sensor_standard/src/main/js/default/test/List.test.js
@@ -14,6 +14,4 @@
  */
 
 require('./SensorOnOffTest.test.js')
-
-
-
+require('./SensorGeomagneticTest.test.js')
diff --git a/sensors/sensor_standard/src/main/js/default/test/SensorGeomagneticTest.test.js b/sensors/sensor_standard/src/main/js/default/test/SensorGeomagneticTest.test.js
new file mode 100755
index 0000000000000000000000000000000000000000..62fa135c1d71173dd8857bf20fc9032b1bd76a8b
--- /dev/null
+++ b/sensors/sensor_standard/src/main/js/default/test/SensorGeomagneticTest.test.js
@@ -0,0 +1,1388 @@
+/*
+ * 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')
+    })
+
+    let GEOMAGNETIC_COMPONENT_YEAR_RESULT = [
+        [6570.3935546875, -146.3289337158203, 54606.0078125, -1.2758207321166992, 83.13726043701172, 6572.02294921875,
+            55000.0703125],
+        [6554.17041015625, -87.19947052001953, 54649.078125, -0.7622424364089966, 83.16046905517578, 6554.75048828125,
+            55040.7734375],
+        [6537.99169921875, -28.231582641601562, 54692.02734375, -0.24740631878376007, 83.18303680419922,
+            6538.052734375, 55081.4296875],
+        [6521.81201171875, 30.73670768737793, 54734.97265625, 0.2700277864933014, 83.20502471923828, 6521.88427734375,
+            55122.15625],
+        [6505.6328125, 89.70511627197266, 54777.90625, 0.7899921536445618, 83.22642517089844, 6506.2509765625,
+            55162.9453125]]
+
+    let GEOMAGNETIC_COMPONENT_COORDINATES_RESULT = [
+        [6570.3935546875, -146.3289337158203, 54606.0078125, -1.2758207321166992, 83.13726043701172, 6572.02294921875,
+            55000.0703125],
+        [39624.28125, 109.8766098022461, -10932.4638671875, 0.15887857973575592, -15.424291610717773, 39624.43359375,
+            41104.921875],
+        [37636.72265625, 104.90892791748047, -10474.810546875, 0.15970633924007416, -15.552550315856934, 37636.8671875,
+            39067.3203125],
+        [5940.583984375, 15772.0927734375, -52480.7578125, 69.36103820800781, -72.19599914550781, 16853.765625,
+            55120.58984375],
+        [5744.87255859375, 14799.48046875, -49969.40234375, 68.78474426269531, -72.37483215332031, 15875.3955078125,
+            52430.61328125]]
+
+    let GEOMAGNETIC_COORDINATES = [[80, 0, 0],
+    [0, 120, 0],
+    [0, 120, 100000],
+    [-80, 240, 0],
+    [-80, 240, 100000]]
+
+    let timeMillis = [1580486400000, 1612108800000, 1643644800000, 1675180800000, 1706716800000]
+
+    /**
+    * @tc.number: Geomagentic_Sensor_Test0010
+    * @tc.name: SensorGeomagenticTest001
+    * @tc.desc: Verification results of the incorrect parameters of the test interface.
+    */
+    it('Geomagentic_Sensor_Test0010', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0010----------------------------------");
+        let promiseArray = []
+        for (let i = 0; i < timeMillis.length; i++) {
+            promiseArray.push(new Promise((resolve, reject) => {
+                let j = i
+                sensor.getGeomagneticField({ 'latitude': 80, 'longitude': 0, 'altitude': 0 }, timeMillis[j],
+                    (error, data) => {
+                        if (error) {
+                            console.info('SensorGeomagenticTest0010 failed');
+                            expect(false).assertTrue();
+                            setTimeout((err) => {
+                                reject(err)
+                            }, 500)
+                        } else {
+                            console.info('SensorGeomagenticTest0010 success x: ' + data.x + ',y: '
+                                + data.y + ',z: ' + data.z + ',geomagneticDip: ' + data.geomagneticDip
+                                + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: '
+                                + data.levelIntensity + ',totalIntensity: ' + data.totalIntensity)
+                            expect(data.x).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[j][0])
+                            expect(data.y).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[j][1])
+                            expect(data.z).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[j][2])
+                            expect(data.deflectionAngle).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[j][3])
+                            expect(data.geomagneticDip).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[j][4])
+                            expect(data.levelIntensity).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[j][5])
+                            expect(data.totalIntensity).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[j][6])
+                            setTimeout(() => {
+                                resolve()
+                            }, 500)
+                        }
+                    })
+            }))
+        }
+        Promise.all(promiseArray).then(done)
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0020
+     * @tc.name: SensorGeomagenticTest002
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0020', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0020----------------------------------");
+        let promiseArray = []
+        for (let i = 0; i < GEOMAGNETIC_COORDINATES.length; i++) {
+            promiseArray.push(new Promise((resolve, reject) => {
+                let j = i
+                sensor.getGeomagneticField({
+                    'latitude': GEOMAGNETIC_COORDINATES[j][0],
+                    'longitude': GEOMAGNETIC_COORDINATES[j][1], 'altitude': GEOMAGNETIC_COORDINATES[j][2]
+                }, timeMillis[0], (error, data) => {
+                    if (error) {
+                        console.info('SensorGeomagenticTest002 failed');
+                        expect(false).assertTrue();
+                        setTimeout((err) => {
+                            reject(err)
+                        }, 500)
+                    } else {
+                        console.info('SensorGeomagenticTest002 success x: ' + data.x + ',y: ' + data.y + ',z: '
+                            + data.z + ',geomagneticDip: ' + data.geomagneticDip
+                            + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                            + ',totalIntensity: ' + data.totalIntensity)
+                        expect(data.x).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[j][0])
+                        expect(data.y).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[j][1])
+                        expect(data.z).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[j][2])
+                        expect(data.deflectionAngle).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[j][3])
+                        expect(data.geomagneticDip).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[j][4])
+                        expect(data.levelIntensity).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[j][5])
+                        expect(data.totalIntensity).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[j][6])
+                        setTimeout(() => {
+                            resolve()
+                        }, 500)
+                    }
+                })
+            }))
+        }
+        Promise.all(promiseArray).then(done)
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0030
+     * @tc.name: SensorGeomagenticTest003
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0030', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0030----------------------------------");
+        let geomagneticComponent = [27779.234375, -6214.9794921875, -14924.6611328125, -27.667943954467773,
+            -12.610970497131348, 28465.9765625, 32141.2109375]
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': 0 }, Number.MAX_VALUE,
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest003 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest003 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(data.x).assertEqual(geomagneticComponent[0])
+                    expect(data.y).assertEqual(geomagneticComponent[1])
+                    expect(data.z).assertEqual(geomagneticComponent[2])
+                    expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                    expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                    expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                    expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0040
+     * @tc.name: SensorGeomagenticTest004
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0040', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0040----------------------------------");
+        let geomagneticComponent = [27779.234375, -6214.9794921875, -14924.6611328125, -27.667943954467773,
+            -12.610970497131348, 28465.9765625, 32141.2109375]
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': 0 }, Number.MIN_VALUE,
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest004 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest004 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(data.x).assertEqual(geomagneticComponent[0])
+                    expect(data.y).assertEqual(geomagneticComponent[1])
+                    expect(data.z).assertEqual(geomagneticComponent[2])
+                    expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                    expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                    expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                    expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0050
+     * @tc.name: SensorGeomagenticTest005
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0050', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0050----------------------------------");
+        let geomagneticComponent = [1824.141845703125, 116.58167266845703, 56727.7734375, 88.15447235107422,
+            3.6568238735198975, 1827.8634033203125, 56757.21484375]
+        sensor.getGeomagneticField({ 'latitude': Number.MAX_VALUE, 'longitude': 0, 'altitude': 0 },
+            timeMillis[0], (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest005 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest005 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(data.x).assertEqual(geomagneticComponent[0])
+                    expect(data.y).assertEqual(geomagneticComponent[1])
+                    expect(data.z).assertEqual(geomagneticComponent[2])
+                    expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                    expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                    expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                    expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0060
+     * @tc.name: SensorGeomagenticTest006
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0060', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0060----------------------------------");
+        let geomagneticComponent = [1824.141845703125, 116.58167266845703, 56727.7734375, 88.15447235107422,
+            3.6568238735198975, 1827.8634033203125, 56757.21484375]
+        sensor.getGeomagneticField({ 'latitude': Number.NaN, 'longitude': 0, 'altitude': 0 }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest006 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest006 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(data.x).assertEqual(geomagneticComponent[0])
+                    expect(data.y).assertEqual(geomagneticComponent[1])
+                    expect(data.z).assertEqual(geomagneticComponent[2])
+                    expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                    expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                    expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                    expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0070
+     * @tc.name: SensorGeomagenticTest007
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0070', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0070----------------------------------");
+        let geomagneticComponent = [14425.57421875, -17156.767578125, -52023.21484375, -66.69005584716797,
+            -49.94255447387695, 22415.4375, 56646.859375]
+        sensor.getGeomagneticField({ 'latitude': Number.NEGATIVE_INFINITY, 'longitude': 0, 'altitude': 0 },
+            timeMillis[0], (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest007 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest007 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(data.x).assertEqual(geomagneticComponent[0])
+                    expect(data.y).assertEqual(geomagneticComponent[1])
+                    expect(data.z).assertEqual(geomagneticComponent[2])
+                    expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                    expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                    expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                    expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0080
+     * @tc.name: SensorGeomagenticTest008
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0080', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0080----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.MAX_VALUE, 'altitude': 0 }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest008 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest008 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue();
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0090
+     * @tc.name: SensorGeomagenticTest009
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0090', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0090----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NaN, 'altitude': 0 }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest009 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest009 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0100
+     * @tc.name: SensorGeomagenticTest010
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0100', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0100----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NEGATIVE_INFINITY, 'altitude': 0 },
+            timeMillis[0], (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest010 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest010 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0110
+     * @tc.name: SensorGeomagenticTest011
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0110', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0110----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.MAX_VALUE }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest011 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest011 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0120
+     * @tc.name: SensorGeomagenticTest012
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0120', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0120----------------------------------");
+        let geomagneticComponent = [27536.40234375, -2248.586669921875, -16022.4306640625, -30.110872268676758,
+            -4.66834020614624, 27628.05859375, 31937.875]
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.MIN_VALUE }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest012 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest012 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(data.x).assertEqual(geomagneticComponent[0])
+                    expect(data.y).assertEqual(geomagneticComponent[1])
+                    expect(data.z).assertEqual(geomagneticComponent[2])
+                    expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                    expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                    expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                    expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0130
+     * @tc.name: SensorGeomagenticTest013
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0130', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0130----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NaN }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest013 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest013 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0140
+     * @tc.name: SensorGeomagenticTest014
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0140', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0140----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NEGATIVE_INFINITY },
+            timeMillis[0], (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest014 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest014 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0150
+     * @tc.name: SensorGeomagenticTest015
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0150', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0150----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NaN, 'altitude': 0 }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest015 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest015 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0160
+     * @tc.name: SensorGeomagenticTest016
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0160', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0160----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NEGATIVE_INFINITY, 'altitude': 0 },
+            timeMillis[0], (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest016 once success');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest016 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0170
+     * @tc.name: SensorGeomagenticTest017
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0170', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0170----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.MAX_VALUE }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest017 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest017 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0180
+     * @tc.name: SensorGeomagenticTest018
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0180', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0180----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NaN }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest018 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest018 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0190
+     * @tc.name: SensorGeomagenticTest019
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0190', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0190----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NEGATIVE_INFINITY },
+            timeMillis[0], (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest019 failed');
+                    expect(false).assertfalse();
+                } else {
+                    console.info('SensorGeomagenticTest019 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0200
+     * @tc.name: SensorGeomagenticTest020
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0200', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0200----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.MAX_VALUE, 'altitude': 0 }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest020 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest020 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue();
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0210
+     * @tc.name: SensorGeomagenticTest021
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0210', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0210----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NaN, 'altitude': 0 }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest021 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest021 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0220
+     * @tc.name: SensorGeomagenticTest022
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0220', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0220----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NEGATIVE_INFINITY, 'altitude': 0 },
+            timeMillis[0], (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest022 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest022 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0230
+     * @tc.name: SensorGeomagenticTest023
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0230', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0230----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.MAX_VALUE }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest023 failed');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest023 success x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0240
+     * @tc.name: SensorGeomagenticTest024
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0240', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0240----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NaN }, timeMillis[0],
+            (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest024 once success');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest024 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0250
+     * @tc.name: SensorGeomagenticTest025
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it('Geomagentic_Sensor_Test0250', 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0250----------------------------------");
+        sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NEGATIVE_INFINITY },
+            timeMillis[0], (error, data) => {
+                if (error) {
+                    console.info('SensorGeomagenticTest025 once success');
+                    expect(false).assertTrue();
+                } else {
+                    console.info('SensorGeomagenticTest025 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue()
+                }
+                setTimeout(() => {
+                    done()
+                }, 500)
+            })
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0260
+     * @tc.name: SensorGeomagenticTest026
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it("Geomagentic_Sensor_Test0260", 0, async function (done) {
+        console.info("---------------------------Geomagentic_Sensor_Test0260----------------------------------");
+        for (var i = 0; i < timeMillis.length; i++) {
+            await sensor.getGeomagneticField({ 'latitude': 80, 'longitude': 0, 'altitude': 0 },
+                timeMillis[i]).then((data) => {
+                    console.info('SensorGeomagenticTest026 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity);
+                    expect(data.x).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][0])
+                    expect(data.y).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][1])
+                    expect(data.z).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][2])
+                    expect(data.deflectionAngle).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][3])
+                    expect(data.geomagneticDip).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][4])
+                    expect(data.levelIntensity).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][5])
+                    expect(data.totalIntensity).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][6])
+                }).catch((error) => {
+                    console.info("promise::catch", error);
+                })
+        }
+        done()
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0270
+     * @tc.name: SensorGeomagenticTest027
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it("Geomagentic_Sensor_Test0270", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0270---------------------------');
+        let geomagneticComponent = [27779.234375, -6214.9794921875, -14924.6611328125, -27.667943954467773,
+            -12.610970497131348, 28465.9765625, 32141.2109375]
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': 0 },
+            Number.MAX_VALUE).then((data) => {
+                console.info('SensorGeomagenticTest027 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(data.x).assertEqual(geomagneticComponent[0])
+                expect(data.y).assertEqual(geomagneticComponent[1])
+                expect(data.z).assertEqual(geomagneticComponent[2])
+                expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0280
+     * @tc.name: SensorGeomagenticTest028
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it("Geomagentic_Sensor_Test0280", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0280---------------------------');
+        let geomagneticComponent = [27779.234375, -6214.9794921875, -14924.6611328125, -27.667943954467773,
+            -12.610970497131348, 28465.9765625, 32141.2109375]
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': 0 },
+            Number.MIN_VALUE).then((data) => {
+                console.info('SensorGeomagenticTest028 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(data.x).assertEqual(geomagneticComponent[0])
+                expect(data.y).assertEqual(geomagneticComponent[1])
+                expect(data.z).assertEqual(geomagneticComponent[2])
+                expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+            }).catch((error) => {
+                console.info("promise::catch", error);
+            });
+        done()
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0290
+     * @tc.name: SensorGeomagenticTest029
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it("Geomagentic_Sensor_Test0290", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0290---------------------------');
+        let geomagneticComponent = [1824.141845703125, 116.58167266845703, 56727.7734375, 88.15447235107422,
+            3.6568238735198975, 1827.8634033203125, 56757.21484375]
+        await sensor.getGeomagneticField({ 'latitude': Number.MAX_VALUE, 'longitude': 0, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest029 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(data.x).assertEqual(geomagneticComponent[0])
+                expect(data.y).assertEqual(geomagneticComponent[1])
+                expect(data.z).assertEqual(geomagneticComponent[2])
+                expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0300
+     * @tc.name: SensorGeomagenticTest030
+     * @tc.desc: Verification results of the incorrect parameters of the test interface.
+     */
+    it("Geomagentic_Sensor_Test0300", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0300---------------------------');
+        let geomagneticComponent = [1824.141845703125, 116.58167266845703, 56727.7734375, 88.15447235107422,
+            3.6568238735198975, 1827.8634033203125, 56757.21484375]
+        await sensor.getGeomagneticField({ 'latitude': Number.NaN, 'longitude': 0, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest030 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(data.x).assertEqual(geomagneticComponent[0])
+                expect(data.y).assertEqual(geomagneticComponent[1])
+                expect(data.z).assertEqual(geomagneticComponent[2])
+                expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /**
+     * @tc.number: Geomagentic_Sensor_Test0310
+     * @tc.name: SensorGeomagenticTest031
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0310", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0310---------------------------');
+        let geomagneticComponent = [14425.57421875, -17156.767578125, -52023.21484375, -66.69005584716797,
+            -49.94255447387695, 22415.4375, 56646.859375]
+        await sensor.getGeomagneticField({ 'latitude': Number.NEGATIVE_INFINITY, 'longitude': 0, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest031 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(data.x).assertEqual(geomagneticComponent[0])
+                expect(data.y).assertEqual(geomagneticComponent[1])
+                expect(data.z).assertEqual(geomagneticComponent[2])
+                expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0320
+     * @tc.name: SensorGeomagenticTest032
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0320", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0320---------------------------');
+        let geomagneticComponent = [NaN, NaN, NaN]
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.MAX_VALUE, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest032 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0330
+     * @tc.name: SensorGeomagenticTest033
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0330", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0330---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NaN, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest033 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0340
+     * @tc.name: SensorGeomagenticTest034
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0340", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0340---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NEGATIVE_INFINITY, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest034 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0350
+     * @tc.name: SensorGeomagenticTest035
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0350", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0350---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.MAX_VALUE },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest035 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0360
+     * @tc.name: SensorGeomagenticTest036
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0360", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0360---------------------------');
+        let geomagneticComponent = [27536.40234375, -2248.586669921875, -16022.4306640625, -30.110872268676758,
+            -4.66834020614624, 27628.05859375, 31937.875]
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.MIN_VALUE },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest036 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(data.x).assertEqual(geomagneticComponent[0])
+                expect(data.y).assertEqual(geomagneticComponent[1])
+                expect(data.z).assertEqual(geomagneticComponent[2])
+                expect(data.geomagneticDip).assertEqual(geomagneticComponent[3])
+                expect(data.deflectionAngle).assertEqual(geomagneticComponent[4])
+                expect(data.levelIntensity).assertEqual(geomagneticComponent[5])
+                expect(data.totalIntensity).assertEqual(geomagneticComponent[6])
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0370
+     * @tc.name: SensorGeomagenticTest037
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0370", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0370---------------------------start');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NaN },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest037 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0380
+     * @tc.name: SensorGeomagenticTest038
+     * @tc.desc:verify app info is not null
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("Geomagentic_Sensor_Test0380", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0380---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NEGATIVE_INFINITY },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest038 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.x) && Number.isNaN(data.y) && Number.isNaN(data.z)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0390
+     * @tc.name: SensorGeomagenticTest039
+     * @tc.desc:verify app info is not null
+     */
+    it('Geomagentic_Sensor_Test0390', 0, async function (done) {
+        for (var i = 0; i < timeMillis.length; i++) {
+            console.info('----------------------Geomagentic_Sensor_Test0390---------------------------');
+            await sensor.getGeomagneticField({ 'latitude': 80, 'longitude': 0, 'altitude': 0 },
+                timeMillis[i]).then((data) => {
+                    console.info('SensorGeomagenticTest039 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity);
+                    expect(data.x).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][0])
+                    expect(data.y).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][1])
+                    expect(data.z).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][2])
+                    expect(data.deflectionAngle).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][3])
+                    expect(data.geomagneticDip).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][4])
+                    expect(data.levelIntensity).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][5])
+                    expect(data.totalIntensity).assertEqual(GEOMAGNETIC_COMPONENT_YEAR_RESULT[i][6])
+                }).catch((error) => {
+                    console.info("promise::catch", error)
+                });
+        }
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0400
+     * @tc.name: SensorGeomagenticTest040
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0400", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0400---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NaN, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest040 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0410
+     * @tc.name: SensorGeomagenticTest041
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0410", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0410---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NEGATIVE_INFINITY, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest041 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0420
+     * @tc.name: SensorGeomagenticTest042
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0420", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0420 max ---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.MAX_VALUE },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest042 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0430
+     * @tc.name: SensorGeomagenticTest043
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0430", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0430---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NaN },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest043 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0440
+     * @tc.name: SensorGeomagenticTest044
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0440", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0440---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NEGATIVE_INFINITY },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest044 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error)
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0450
+     * @tc.name: SensorGeomagenticTest045
+     * @tc.desc:verify app info is not null
+     */
+    it('Geomagentic_Sensor_Test0450', 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0450---------------------------');
+        for (var i = 0; i < GEOMAGNETIC_COORDINATES.length; i++) {
+            await sensor.getGeomagneticField({
+                'latitude': GEOMAGNETIC_COORDINATES[i][0],
+                'longitude': GEOMAGNETIC_COORDINATES[i][1], 'altitude': GEOMAGNETIC_COORDINATES[i][2]
+            },
+                timeMillis[0]).then((data) => {
+                    console.info('SensorGeomagenticTest045 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                        + ',geomagneticDip: ' + data.geomagneticDip
+                        + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                        + ',totalIntensity: ' + data.totalIntensity)
+                    expect(data.x).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[i][0])
+                    expect(data.y).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[i][1])
+                    expect(data.z).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[i][2])
+                    expect(data.deflectionAngle).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[i][3])
+                    expect(data.geomagneticDip).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[i][4])
+                    expect(data.levelIntensity).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[i][5])
+                    expect(data.totalIntensity).assertEqual(GEOMAGNETIC_COMPONENT_COORDINATES_RESULT[i][6])
+                }).catch((error) => {
+                    console.info("promise::catch", error);
+                });
+        }
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0460
+     * @tc.name: SensorGeomagenticTest046
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0460", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0460---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.MAX_VALUE, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest046 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue();
+            }).catch((error) => {
+                console.info("promise::catch", error);
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0470
+     * @tc.name: SensorGeomagenticTest047
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0470", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0470---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NaN, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest047 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error);
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0480
+     * @tc.name: SensorGeomagenticTest048
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0480", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0480---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': Number.NEGATIVE_INFINITY, 'altitude': 0 },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest048 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.deflectionAngle) && Number.isNaN(data.geomagneticDip)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error);
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0490
+     * @tc.name: SensorGeomagenticTest049
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0490", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0490---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.MAX_VALUE },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest049 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error);
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0500
+     * @tc.name: SensorGeomagenticTest050
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0500", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0500---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NaN },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest050 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error);
+            });
+        done()
+    })
+
+    /*
+     * @tc.number: Geomagentic_Sensor_Test0510
+     * @tc.name: SensorGeomagenticTest051
+     * @tc.desc:verify app info is not null
+     */
+    it("Geomagentic_Sensor_Test0510", 0, async function (done) {
+        console.info('----------------------Geomagentic_Sensor_Test0510---------------------------');
+        await sensor.getGeomagneticField({ 'latitude': 0, 'longitude': 0, 'altitude': Number.NEGATIVE_INFINITY },
+            timeMillis[0]).then((data) => {
+                console.info('SensorGeomagenticTest051 x: ' + data.x + ',y: ' + data.y + ',z: ' + data.z
+                    + ',geomagneticDip: ' + data.geomagneticDip
+                    + ',deflectionAngle: ' + data.deflectionAngle + ',levelIntensity: ' + data.levelIntensity
+                    + ',totalIntensity: ' + data.totalIntensity)
+                expect(Number.isNaN(data.levelIntensity) && Number.isNaN(data.totalIntensity)).assertTrue()
+            }).catch((error) => {
+                console.info("promise::catch", error);
+            });
+        done()
+    })
+})