1/* 2 * Copyright (C) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15import sensor from '@system.sensor' 16 17import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' 18 19describe("SensorJsTest", function () { 20 beforeAll(function() { 21 /* 22 * @tc.setup: setup invoked before all testcases 23 */ 24 console.info('beforeAll caled') 25 }) 26 27 afterAll(function() { 28 /* 29 * @tc.teardown: teardown invoked after all testcases 30 */ 31 console.info('afterAll caled') 32 }) 33 34 beforeEach(function() { 35 /* 36 * @tc.setup: setup invoked before each testcases 37 */ 38 console.info('beforeEach caled') 39 }) 40 41 afterEach(function() { 42 /* 43 * @tc.teardown: teardown invoked after each testcases 44 */ 45 console.info('afterEach caled') 46 }) 47 48 /* 49 * @tc.name:SensorJsTest001 50 * @tc.desc:verify app info is not null 51 * @tc.type: FUNC 52 * @tc.require: SR000H0ALK, AR000H0ALM 53 */ 54 it("SensorJsTest001", 0, async function (done) { 55 console.info('----------------------SensorJsTest001---------------------------'); 56 sensor.subscribeAccelerometer({ 57 interval: 'normal', 58 success: function(data) { 59 expect(typeof(data.x)).assertEqual("number"); 60 expect(typeof(data.y)).assertEqual("number"); 61 expect(typeof(data.z)).assertEqual("number"); 62 console.info("SensorJsTest001 success" + JSON.stringify(data)); 63 }, 64 fail: function(data, code) { 65 expect(false).assertTrue(); 66 console.error('Subscription failed. Code: ' + code + '; Data: ' + data); 67 }, 68 }); 69 setTimeout(()=>{ 70 try { 71 sensor.unsubscribeAccelerometer(); 72 } catch (error) { 73 console.info('SensorJsTest001 unsubscribe failed' + error); 74 expect(false).assertTrue(); 75 } 76 setTimeout(()=>{ 77 expect(true).assertTrue(); 78 done(); 79 }, 500); 80 }, 1000); 81 }) 82 83 /* 84 * @tc.name:SensorJsTest002 85 * @tc.desc:verify app info is not null 86 * @tc.type: FUNC 87 * @tc.require: SR000H0ALK, AR000H0ALM 88 */ 89 it("SensorJsTest002", 0, async function (done) { 90 console.info('----------------------SensorJsTest002---------------------------'); 91 sensor.subscribeAccelerometer({ 92 interval: 'xxx', 93 success: function(data) { 94 expect(false).assertTrue(); 95 console.info("SensorJsTest002 success" + JSON.stringify(data)); 96 done(); 97 }, 98 fail: function(data, code) { 99 expect(true).assertTrue(); 100 console.error('SensorJsTest002 Subscription failed. Code: ' + code + '; Data: ' + data); 101 done(); 102 }, 103 }); 104 }) 105 106 /* 107 * @tc.name:SensorJsTest003 108 * @tc.desc:verify app info is not null 109 * @tc.type: FUNC 110 * @tc.require: SR000H0ALK, AR000H0ALM 111 */ 112 it("SensorJsTest003", 0, async function (done) { 113 console.info('----------------------SensorJsTest003---------------------------'); 114 try { 115 sensor.subscribeAccelerometer({ 116 interval: 'xxx', 117 success: function(data) { 118 expect(false).assertTrue(); 119 console.info("SensorJsTest003 success" + JSON.stringify(data)); 120 done(); 121 } 122 }); 123 } catch (error) { 124 console.info('SensorJsTest003 Subscription failed' + error); 125 expect(true).assertTrue(); 126 done(); 127 } 128 }) 129 130 /* 131 * @tc.name:SensorJsTest004 132 * @tc.desc:verify app info is not null 133 * @tc.type: FUNC 134 * @tc.require: SR000H0ALK, AR000H0ALM 135 */ 136 it("SensorJsTest004", 0, async function (done) { 137 console.info('----------------------SensorJsTest004---------------------------'); 138 try { 139 sensor.subscribeAccelerometer({ 140 interval: 'normal', 141 }); 142 } catch (error) { 143 console.info('SensorJsTest004 Subscription failed' + error); 144 expect(true).assertTrue(); 145 done(); 146 } 147 }) 148 149 /* 150 * @tc.name:SensorJsTest005 151 * @tc.desc:verify app info is not null 152 * @tc.type: FUNC 153 * @tc.require: SR000H0ALK, AR000H0ALM 154 */ 155 it("SensorJsTest005", 0, async function (done) { 156 console.info('----------------------SensorJsTest005---------------------------'); 157 try { 158 sensor.unsubscribeAccelerometer(); 159 } catch (error) { 160 console.info(error); 161 expect(true).assertTrue(); 162 done(); 163 } 164 }) 165 166 /* 167 * @tc.name:SensorJsTest006 168 * @tc.desc:verify app info is not null 169 * @tc.type: FUNC 170 * @tc.require: SR000H0ALK, AR000H0ALM 171 */ 172 it("SensorJsTest006", 0, async function (done) { 173 console.info('----------------------SensorJsTest006---------------------------'); 174 try { 175 sensor.unsubscribeAccelerometer('xxx'); 176 } catch (error) { 177 console.info(error); 178 expect(true).assertTrue(); 179 done(); 180 } 181 }) 182 183 /* 184 * @tc.name:SensorJsTest007 185 * @tc.desc:verify app info is not null 186 * @tc.type: FUNC 187 * @tc.require: SR000H0ALK, AR000H0ALM 188 */ 189 it("SensorJsTest007", 0, async function (done) { 190 console.info('----------------------SensorJsTest007---------------------------'); 191 sensor.subscribeCompass({ 192 success: function(data) { 193 console.log('SensorJsTest007 get data direction:' + ret.direction); 194 expect(typeof(data.direction)).assertEqual("number"); 195 }, 196 fail: function(data, code) { 197 console.error('SensorJsTest007 Subscription failed. Code: ' + code + '; Data: ' + data); 198 expect(false).assertTrue(); 199 }, 200 }); 201 setTimeout(()=>{ 202 try { 203 sensor.unsubscribeCompass(); 204 } catch (error) { 205 console.info(error); 206 expect(false).assertTrue(); 207 } 208 setTimeout(()=>{ 209 expect(true).assertTrue(); 210 done(); 211 }, 500); 212 }, 1000); 213 }) 214 215 /* 216 * @tc.name:SensorJsTest008 217 * @tc.desc:verify app info is not null 218 * @tc.type: FUNC 219 * @tc.require: SR000H0ALK, AR000H0ALM 220 */ 221 it("SensorJsTest008", 0, async function (done) { 222 sensor.subscribeProximity({ 223 success: function(data) { 224 expect(typeof(data.distance)).assertEqual("number"); 225 console.info("SensorJsTest008 subscribeProximity" + JSON.stringify(data)); 226 }, 227 fail: function(data, code) { 228 console.error('SensorJsTest008 Subscription failed. Code: ' + code + '; Data: ' + data); 229 expect(true).assertTrue(); 230 }, 231 }); 232 setTimeout(()=>{ 233 try { 234 sensor.unsubscribeProximity(); 235 } catch (error) { 236 console.info(error); 237 } 238 setTimeout(()=>{ 239 expect(true).assertTrue(); 240 done(); 241 }, 500); 242 }, 1000); 243 }) 244 245 /* 246 * @tc.name:SensorJsTest009 247 * @tc.desc:verify app info is not null 248 * @tc.type: FUNC 249 * @tc.require: SR000H0ALK, AR000H0ALM 250 */ 251 it("SensorJsTest009", 0, function (done) { 252 sensor.subscribeLight({ 253 success: function(data) { 254 expect(typeof(data.intensity)).assertEqual("number"); 255 console.info("SensorJsTest009 subscribeLight" + JSON.stringify(data)); 256 }, 257 fail: function(data, code) { 258 console.error('SensorJsTest009 Subscription failed. Code: ' + code + '; Data: ' + data); 259 expect(false).assertTrue(); 260 }, 261 }); 262 setTimeout(()=>{ 263 try { 264 sensor.unsubscribeLight(); 265 } catch (error) { 266 console.info(error); 267 expect(false).assertTrue(); 268 } 269 setTimeout(()=>{ 270 expect(true).assertTrue(); 271 done(); 272 }, 500); 273 }, 1000); 274 }) 275 276 /* 277 * @tc.name:SensorJsTest010 278 * @tc.desc:verify app info is not null 279 * @tc.type: FUNC 280 * @tc.require: SR000H0ALK, AR000H0ALM 281 */ 282 it("SensorJsTest010", 0, async function (done) { 283 sensor.subscribeStepCounter({ 284 success: function(data) { 285 expect(typeof(data.steps)).assertEqual("number"); 286 console.info("SensorJsTest010 subscribeStepCounter" + JSON.stringify(data)); 287 }, 288 fail: function(data, code) { 289 console.error('SensorJsTest010 Subscription failed. Code: ' + code + '; Data: ' + data); 290 expect(true).assertTrue(); 291 }, 292 }); 293 setTimeout(()=>{ 294 try { 295 sensor.unsubscribeStepCounter(); 296 } catch (error) { 297 console.info(error); 298 } 299 setTimeout(()=>{ 300 expect(true).assertTrue(); 301 done(); 302 }, 500); 303 }, 1000); 304 }) 305 306 /* 307 * @tc.name:SensorJsTest011 308 * @tc.desc:verify app info is not null 309 * @tc.type: FUNC 310 * @tc.require: SR000H0ALK, AR000H0ALM 311 */ 312 it("SensorJsTest011", 0, async function (done) { 313 sensor.subscribeBarometer({ 314 success: function(data) { 315 expect(typeof(data.pressure)).assertEqual("number"); 316 console.info("subscribeBarometer" + JSON.stringify(data)); 317 }, 318 fail: function(data, code) { 319 console.error('SensorJsTest011 Subscription failed. Code: ' + code + '; Data: ' + data); 320 expect(true).assertTrue(); 321 }, 322 }); 323 setTimeout(()=>{ 324 try { 325 sensor.unsubscribeBarometer(); 326 } catch (error) { 327 console.info(error); 328 } 329 setTimeout(()=>{ 330 expect(true).assertTrue(); 331 done(); 332 }, 500); 333 }, 1000); 334 }) 335 336 /* 337 * @tc.name:SensorJsTest012 338 * @tc.desc:verify app info is not null 339 * @tc.type: FUNC 340 * @tc.require: SR000H0ALK, AR000H0ALM 341 */ 342 it("SensorJsTest012", 0, function (done) { 343 sensor.subscribeHeartRate({ 344 success: function(data) { 345 expect(typeof(data.heartRate)).assertEqual("number"); 346 console.info("SensorJsTest012 subscribeHeartRate" + JSON.stringify(data)); 347 }, 348 fail: function(data, code) { 349 console.error('SensorJsTest012 Subscription failed. Code: ' + code + '; Data: ' + data); 350 expect(true).assertTrue(); 351 }, 352 }); 353 setTimeout(()=>{ 354 try { 355 sensor.unsubscribeHeartRate(); 356 } catch (error) { 357 console.info(error); 358 } 359 setTimeout(()=>{ 360 expect(true).assertTrue(); 361 done(); 362 }, 500); 363 }, 1000); 364 }) 365 366 /* 367 * @tc.name:SensorJsTest013 368 * @tc.desc:verify app info is not null 369 * @tc.type: FUNC 370 * @tc.require: SR000H0ALK, AR000H0ALM 371 */ 372 it("SensorJsTest013", 0, async function (done) { 373 console.info('----------------------SensorJsTest013---------------------------'); 374 sensor.subscribeOnBodyState({ 375 success: function(data) { 376 expect(typeof(data.value)).assertEqual("boolean"); 377 console.info("SensorJsTest013 subscribeOnBodyState" + JSON.stringify(data)); 378 }, 379 fail: function(data, code) { 380 console.error('SensorJsTest013 Subscription failed. Code: ' + code + '; Data: ' + data); 381 expect(true).assertTrue(); 382 }, 383 }); 384 setTimeout(()=>{ 385 try { 386 sensor.unsubscribeOnBodyState(); 387 } catch (error) { 388 console.info(error); 389 } 390 setTimeout(()=>{ 391 expect(true).assertTrue(); 392 done(); 393 }, 500); 394 }, 1000); 395 }) 396 397 /* 398 * @tc.name:SensorJsTest014 399 * @tc.desc:verify app info is not null 400 * @tc.type: FUNC 401 * @tc.require: SR000H0ALK, AR000H0ALM 402 */ 403 it('SensorJsTest014', 0, async function (done) { 404 console.info("---------------------------SensorJsTest014----------------------------------"); 405 try { 406 sensor.getOnBodyState({ 407 success: function(data) { 408 expect(typeof(data.value)).assertEqual("boolean"); 409 console.info("subscribeOnBodyState" + JSON.stringify(data)); 410 done(); 411 } 412 }); 413 } catch (error) { 414 console.info(error); 415 expect(false).assertTrue(); 416 done(); 417 } 418 }) 419 420 /* 421 * @tc.name:SensorJsTest015 422 * @tc.desc:verify app info is not null 423 * @tc.type: FUNC 424 * @tc.require: SR000H0ALK, AR000H0ALM 425 */ 426 it('SensorJsTest015', 0, async function (done) { 427 console.info("---------------------------SensorJsTest015----------------------------------"); 428 try { 429 sensor.getOnBodyState(); 430 } catch (error) { 431 console.info(error); 432 expect(true).assertTrue(); 433 done(); 434 } 435 }) 436 437 /* 438 * @tc.name:SensorJsTest016 439 * @tc.desc:verify app info is not null 440 * @tc.type: FUNC 441 * @tc.require: SR000H0ALK, AR000H0ALM 442 */ 443 it("SensorJsTest016", 0, async function (done) { 444 console.info('----------------------SensorJsTest016---------------------------'); 445 sensor.subscribeDeviceOrientation({ 446 interval: 'normal', 447 success: function(data) { 448 expect(typeof(data.alpha)).assertEqual("number"); 449 expect(typeof(data.beta)).assertEqual("number"); 450 expect(typeof(data.gamma)).assertEqual("number"); 451 console.info("SensorJsTest016 subscribeDeviceOrientation" + JSON.stringify(data)); 452 }, 453 fail: function(data, code) { 454 console.error('SensorJsTest016 Subscription failed. Code: ' + code + '; Data: ' + data); 455 expect(false).assertTrue(); 456 }, 457 }); 458 setTimeout(()=>{ 459 try { 460 sensor.unsubscribeDeviceOrientation(); 461 } catch (error) { 462 console.info(error); 463 expect(false).assertTrue(); 464 } 465 setTimeout(()=>{ 466 expect(true).assertTrue(); 467 done(); 468 }, 500); 469 }, 1000); 470 }) 471 472 /* 473 * @tc.name:SensorJsTest017 474 * @tc.desc:verify app info is not null 475 * @tc.type: FUNC 476 * @tc.require: SR000H0ALK, AR000H0ALM 477 */ 478 it("SensorJsTest017", 0, async function (done) { 479 console.info('----------------------SensorJsTest017---------------------------'); 480 sensor.subscribeGyroscope({ 481 interval: 'normal', 482 success: function(data) { 483 expect(typeof(data.x)).assertEqual("number"); 484 expect(typeof(data.y)).assertEqual("number"); 485 expect(typeof(data.z)).assertEqual("number"); 486 console.info("SensorJsTest017 subscribeGyroscope" + JSON.stringify(data)); 487 }, 488 fail: function(data, code) { 489 console.error('SensorJsTest017 Subscription failed. Code: ' + code + '; Data: ' + data); 490 expect(false).assertTrue(); 491 }, 492 }); 493 setTimeout(()=>{ 494 try { 495 sensor.unsubscribeGyroscope(); 496 } catch (error) { 497 console.info(error); 498 expect(false).assertTrue(); 499 } 500 setTimeout(()=>{ 501 expect(true).assertTrue(); 502 done(); 503 }, 500); 504 }, 1000); 505 }) 506}) 507