Skip to content

X
Xts Acts

OpenHarmony / Xts Acts
10 个月 前同步成功

通知 9
Star 22
Fork 0
X
Xts Acts

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

未验证 提交 79f25b6b 编写于 作者: O openharmony_ci 提交者： Gitee
浏览文件
操作

!1514 新增sensor算法接口用例 

Merge pull request !1514 from logic42/master
上级 0db962de 8cd41186
显示空白变更内容
内联 并排
Showing with 1389 addition and 3 deletion
sensors/sensor_standard/src/main/js/default/test/List.test.js
浏览文件 @ 79f25b6b
......@@ -14,6 +14,4 @@
*/
require('./SensorOnOffTest.test.js')
require('./SensorGeomagneticTest.test.js')
sensors/sensor_standard/src/main/js/default/test/SensorGeomagneticTest.test.js 0 → 100755
浏览文件 @ 79f25b6b
/*
* 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()
})
})
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或