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 {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' 16import data_relationalStore from '@ohos.data.relationalStore' 17import ability_featureAbility from '@ohos.ability.featureAbility' 18import dataSharePredicates from '@ohos.data.dataSharePredicates'; 19 20const TAG = "[RELATIONAL_STORE_JSKITS_TEST]" 21const CREATE_TABLE_ALL_DATA_TYPE_SQL = "CREATE TABLE IF NOT EXISTS AllDataType " 22 + "(id INTEGER PRIMARY KEY AUTOINCREMENT, " 23 + "integerValue INTEGER , longValue INTEGER , shortValue INTEGER , booleanValue INTEGER , " 24 + "doubleValue REAL , floatValue REAL , stringValue TEXT , blobValue BLOB , clobValue TEXT , " 25 + "byteValue INTEGER , dateValue INTEGER , timeValue INTEGER , timestampValue INTEGER , " 26 + "calendarValue INTEGER , characterValue TEXT , primIntValue INTEGER , primLongValue INTEGER , " 27 + "primShortValue INTEGER , primFloatValue REAL , primDoubleValue REAL , " 28 + "primBooleanValue INTEGER , primByteValue INTEGER , primCharValue TEXT, `order` INTEGER);"; 29 30const STORE_CONFIG = { 31 name: "Predicates.db", 32 securityLevel: data_relationalStore.SecurityLevel.S1, 33} 34var rdbStore = undefined 35var context = ability_featureAbility.getContext() 36var DOUBLE_MAX = 9223372036854775807; 37var u8 = new Uint8Array([1, 2, 3]) 38const valueBucket1 = { 39 "integerValue": 2147483647, 40 "doubleValue": DOUBLE_MAX, 41 "booleanValue": true, 42 "floatValue": -0.123, 43 "longValue": 9223372036854775807, 44 "shortValue": 32767, 45 "characterValue": ' ', 46 "stringValue": "ABCDEFGHIJKLMN", 47 "blobValue": u8, 48 "byteValue": 127, 49} 50const valueBucket2 = { 51 "integerValue": 1, 52 "doubleValue": 1.0, 53 "booleanValue": false, 54 "floatValue": 1.0, 55 "longValue": 1, 56 "shortValue": 1, 57 "characterValue": '中', 58 "stringValue": "ABCDEFGHIJKLMN", 59 "blobValue": u8, 60 "byteValue": 1, 61} 62const valueBucket3 = { 63 "integerValue": -2147483648, 64 "doubleValue": Number.MIN_VALUE, 65 "booleanValue": false, 66 "floatValue": 0.1234567, 67 "longValue": -9223372036854775808, 68 "shortValue": -32768, 69 "characterValue": '#', 70 "stringValue": "ABCDEFGHIJKLMN", 71 "blobValue": u8, 72 "byteValue": -128, 73} 74const valueBucket4 = { 75 "integerValue": -2147483648, 76 "doubleValue": Number.MIN_VALUE, 77 "booleanValue": false, 78 "floatValue": 0.1234567, 79 "longValue": -9223372036854775808, 80 "shortValue": -32768, 81 "characterValue": '#', 82 "stringValue": "OPQRST", 83 "blobValue": u8, 84 "byteValue": -128, 85} 86describe('rdbPredicatesTest', function () { 87 beforeAll(async function () { 88 console.info(TAG + 'beforeAll') 89 rdbStore = await data_relationalStore.getRdbStore(context, STORE_CONFIG); 90 await rdbStore.executeSql(CREATE_TABLE_ALL_DATA_TYPE_SQL, null); 91 await buildAllDataType1(); 92 await buildAllDataType2(); 93 await buildAllDataType3(); 94 }) 95 96 beforeEach(function () { 97 console.info(TAG + 'beforeEach') 98 }) 99 100 afterEach(function () { 101 console.info(TAG + 'afterEach') 102 }) 103 104 afterAll(async function () { 105 console.info(TAG + 'afterAll') 106 rdbStore = null 107 await data_relationalStore.deleteRdbStore(context, "Predicates.db"); 108 }) 109 110 async function buildAllDataType1() { 111 console.log(TAG + "buildAllDataType1 start"); 112 await rdbStore.insert("AllDataType", valueBucket1) 113 } 114 115 async function buildAllDataType2() { 116 console.log(TAG + "buildAllDataType2 start"); 117 await rdbStore.insert("AllDataType", valueBucket2) 118 } 119 120 async function buildAllDataType3() { 121 console.log(TAG + "buildAllDataType3 start"); 122 await rdbStore.insert("AllDataType", valueBucket3) 123 } 124 125 console.log(TAG + "*************Unit Test Begin*************"); 126 127 /** 128 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0010 129 * @tc.name Normal test case of predicates, test "equalTo" for boolean value 130 * @tc.desc 1.Execute equalTo("boolType", true) 131 * 2.Query data 132 */ 133 it('testEqualTo0001', 0, async function (done) { 134 console.log(TAG + "************* testEqualTo0001 start *************"); 135 136 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 137 predicates.equalTo("booleanValue", true); 138 let result = await rdbStore.query(predicates); 139 expect(1).assertEqual(result.rowCount); 140 result.close() 141 result = null 142 143 done(); 144 console.log(TAG + "************* testEqualTo0001 end *************"); 145 }) 146 147 /** 148 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0011 149 * @tc.name Normal test case of predicates, test "or" 150 * @tc.desc 1.Execute equalTo().or().equalTo() 151 * 2.Query data 152 */ 153 it('testEqualTo0002', 0, async function (done) { 154 console.log(TAG + "************* testEqualTo0002 start *************"); 155 156 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 157 predicates.equalTo("byteValue", -128).or().equalTo("byteValue", 1); 158 let result = await rdbStore.query(predicates); 159 expect(2).assertEqual(result.rowCount); 160 result.close() 161 result = null 162 163 done(); 164 console.log(TAG + "************* testEqualTo0002 end *************"); 165 }) 166 167 /** 168 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0012 169 * @tc.name Normal test case of predicates, test "equalTo" for string value 170 * @tc.desc 1.Execute equalTo("stringValue", "ABCDEFGHIJKLMN") 171 * 2.Query data 172 */ 173 it('testEqualTo0003', 0, async function (done) { 174 console.log(TAG + "************* testEqualTo0003 start *************"); 175 176 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 177 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN"); 178 let result = await rdbStore.query(predicates); 179 expect(3).assertEqual(result.rowCount); 180 result.close() 181 result = null 182 183 done(); 184 console.log(TAG + "************* testEqualTo0003 end *************"); 185 }) 186 187 /** 188 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0013 189 * @tc.name Normal test case of predicates, test "equalTo" for boundary value of doubleValue 190 * @tc.desc 1.Execute equalTo("doubleValue", DOUBLE_MAX) 191 * 2.Query data 192 */ 193 it('testEqualTo0004', 0, async function (done) { 194 console.log(TAG + "************* testEqualTo0004 start *************"); 195 196 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 197 predicates.equalTo("doubleValue", DOUBLE_MAX); 198 let result = await rdbStore.query(predicates); 199 expect(1).assertEqual(result.rowCount); 200 result.close() 201 result = null 202 203 done(); 204 console.log(TAG + "************* testEqualTo0004 end *************"); 205 }) 206 207 /** 208 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0014 209 * @tc.name Normal test case of predicates, test "equalTo" for boundary value of shortValue 210 * @tc.desc 1.Execute equalTo("shortValue", -32768.0) 211 * 2.Query data 212 */ 213 it('testEqualTo0005', 0, async function (done) { 214 console.log(TAG + "************* testEqualTo0005 start *************"); 215 216 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 217 predicates.equalTo("shortValue", -32768.0); 218 let result = await rdbStore.query(predicates); 219 expect(1).assertEqual(result.rowCount); 220 result.close() 221 result = null 222 223 done(); 224 console.log(TAG + "************* testEqualTo0005 end *************"); 225 }) 226 227 /** 228 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0015 229 * @tc.name Normal test case of predicates, test "equalTo" for integer value 230 * @tc.desc 1.Execute equalTo("integerValue", 1) 231 * 2.Query data 232 * 3.Execute getLong 233 */ 234 it('testEqualTo0006', 0, async function (done) { 235 console.log(TAG + "************* testEqualTo0006 start *************"); 236 237 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 238 predicates.equalTo("integerValue", 1); 239 let result = await rdbStore.query(predicates); 240 expect(true).assertEqual(result.goToFirstRow()); 241 expect(2).assertEqual(result.getLong(0)); 242 result.close() 243 244 done(); 245 console.log(TAG + "************* testEqualTo0006 end *************"); 246 }) 247 248 /** 249 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0016 250 * @tc.name Normal test case of predicates, test "equalTo" for long value 251 * @tc.desc 1.Execute equalTo("longValue", 1) 252 * 2.Query data 253 * 3.Execute getLong 254 */ 255 it('testEqualTo0007', 0, async function (done) { 256 console.log(TAG + "************* testEqualTo0007 start *************"); 257 258 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 259 predicates.equalTo("longValue", 1); 260 let result = await rdbStore.query(predicates); 261 expect(true).assertEqual(result.goToFirstRow()); 262 expect(2).assertEqual(result.getLong(0)) 263 result.close() 264 265 done(); 266 console.log(TAG + "************* testEqualTo0007 end *************"); 267 }) 268 269 /** 270 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0017 271 * @tc.name Normal test case of predicates, test "equalTo" for float type 272 * @tc.desc 1.Execute equalTo("floatValue", -0.123) 273 * 2.Query data 274 * 3.Execute getLong 275 */ 276 it('testEqualTo0008', 0, async function (done) { 277 console.log(TAG + "************* testEqualTo0008 start *************"); 278 279 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 280 predicates.equalTo("floatValue", -0.123); 281 let result = await rdbStore.query(predicates); 282 expect(true).assertEqual(result.goToFirstRow()); 283 expect(1).assertEqual(result.getLong(0)) 284 result.close() 285 result = null 286 287 done(); 288 console.log(TAG + "************* testEqualTo0008 end *************"); 289 }) 290 291 /** 292 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0018 293 * @tc.name Normal test case of predicates, test "equalTo" for true param 294 * @tc.desc 1.Execute equalTo('1', 1) 295 * 2.Query data 296 * 3.Execute equalTo('1', Number.NaN) 297 * 4.Query data 298 */ 299 it('testEqualTo0009', 0, async function (done) { 300 console.log(TAG + "************* testEqualTo0009 start *************"); 301 302 let predicates1 = new data_relationalStore.RdbPredicates("AllDataType"); 303 predicates1.equalTo('1', 1); 304 let result1 = await rdbStore.query(predicates1); 305 expect(true).assertEqual(result1.goToFirstRow()); 306 expect(3).assertEqual(result1.rowCount) 307 result1.close() 308 result1 = null 309 310 let predicates2 = new data_relationalStore.RdbPredicates("AllDataType"); 311 predicates2.equalTo('1', Number.NaN); 312 let result2 = await rdbStore.query(predicates2); 313 expect(0).assertEqual(result2.rowCount) 314 result2.close() 315 result2 = null 316 317 done(); 318 console.log(TAG + "************* testEqualTo0009 end *************"); 319 }) 320 321 /** 322 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0020 323 * @tc.name Normal test case of predicates, test "notEqualTo" for boolean value 324 * @tc.desc 1.Execute notEqualTo("boolType", true) 325 * 2.Query data 326 */ 327 it('testNotEqualTo0001', 0, async function (done) { 328 console.log(TAG + "************* testNotEqualTo0001 start *************"); 329 330 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 331 predicates.notEqualTo("booleanValue", true); 332 let result = await rdbStore.query(predicates); 333 expect(2).assertEqual(result.rowCount); 334 result.close() 335 result = null 336 337 done(); 338 console.log(TAG + "************* testNotEqualTo0001 end *************"); 339 }) 340 341 /** 342 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0021 343 * @tc.name Normal test case of predicates, test "notEqualTo" for byte value 344 * @tc.desc 1.Execute notEqualTo("byteValue", -128) 345 * 2.Execute notEqualTo("byteValue", 1) 346 * 3.Query data 347 */ 348 it('testNotEqualTo0002', 0, async function (done) { 349 console.log(TAG + "************* testNotEqualTo0002 start *************"); 350 351 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 352 predicates.notEqualTo("byteValue", -128); 353 predicates.notEqualTo("byteValue", 1); 354 let result = await rdbStore.query(predicates); 355 expect(1).assertEqual(result.rowCount); 356 result.close() 357 result = null 358 359 done(); 360 console.log(TAG + "************* testNotEqualTo0002 end *************"); 361 }) 362 363 /** 364 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0022 365 * @tc.name Normal test case of predicates, test "notEqualTo" for string value 366 * @tc.desc 1.Execute notEqualTo("stringValue", "ABCDEFGHIJKLMN") 367 * 2.Query data 368 */ 369 it('testNotEqualTo0003', 0, async function (done) { 370 console.log(TAG + "************* testNotEqualTo0003 start *************"); 371 372 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 373 predicates.notEqualTo("stringValue", "ABCDEFGHIJKLMN"); 374 let result = await rdbStore.query(predicates); 375 expect(0).assertEqual(result.rowCount); 376 result.close() 377 result = null 378 379 done(); 380 console.log(TAG + "************* testNotEqualTo0003 end *************"); 381 }) 382 383 /** 384 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0023 385 * @tc.name Normal test case of predicates, test "notEqualTo" for double value 386 * @tc.desc 1.Execute notEqualTo ("doubleValue", DOUBLE_MAX) 387 * 2.Query data 388 */ 389 it('testNotEqualTo0004', 0, async function (done) { 390 console.log(TAG + "************* testNotEqualTo0004 start *************"); 391 392 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 393 predicates.notEqualTo("doubleValue", DOUBLE_MAX); 394 let result = await rdbStore.query(predicates); 395 expect(2).assertEqual(result.rowCount); 396 result.close() 397 result = null 398 399 done(); 400 console.log(TAG + "************* testNotEqualTo0004 end *************"); 401 }) 402 403 /** 404 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0024 405 * @tc.name Normal test case of predicates, test "notEqualTo" for boundary value of shortValue 406 * @tc.desc 1.Execute notEqualTo ("shortValue", -32768) 407 * 2.Query data 408 */ 409 it('testNotEqualTo0005', 0, async function (done) { 410 console.log(TAG + "************* testNotEqualTo0005 start *************"); 411 412 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 413 predicates.notEqualTo("shortValue", -32768); 414 let result = await rdbStore.query(predicates); 415 expect(2).assertEqual(result.rowCount); 416 result.close() 417 result = null 418 419 done(); 420 console.log(TAG + "************* testNotEqualTo0005 end *************"); 421 }) 422 423 /** 424 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0025 425 * @tc.name Normal test case of predicates, test "notEqualTo" for integer value 426 * @tc.desc 1.Execute notEqualTo ("integerValue", 1) 427 * 2.Query data 428 */ 429 it('testNotEqualTo0006', 0, async function (done) { 430 console.log(TAG + "************* testNotEqualTo0006 start *************"); 431 432 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 433 predicates.notEqualTo("integerValue", 1); 434 let result = await rdbStore.query(predicates); 435 expect(2).assertEqual(result.rowCount); 436 result.close() 437 result = null 438 439 done(); 440 console.log(TAG + "************* testNotEqualTo0006 end *************"); 441 }) 442 443 /** 444 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0026 445 * @tc.name Normal test case of predicates, test "notEqualTo" for long value 446 * @tc.desc 1.Execute notEqualTo ("longValue", 1) 447 * 2.Query data 448 */ 449 it('testNotEqualTo0007', 0, async function (done) { 450 console.log(TAG + "************* testNotEqualTo0007 start *************"); 451 452 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 453 predicates.notEqualTo("longValue", 1); 454 let result = await rdbStore.query(predicates); 455 expect(2).assertEqual(result.rowCount); 456 result.close() 457 result = null 458 459 done(); 460 console.log(TAG + "************* testNotEqualTo0007 end *************"); 461 }) 462 463 /** 464 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0027 465 * @tc.name Normal test case of predicates, test "notEqualTo" for float value 466 * @tc.desc 1.Execute notEqualTo ("floatValue", -0.123) 467 * 2.Query data 468 */ 469 it('testNotEqualTo0008', 0, async function (done) { 470 console.log(TAG + "************* testNotEqualTo0008 start *************"); 471 472 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 473 predicates.notEqualTo("floatValue", -0.123); 474 let result = await rdbStore.query(predicates); 475 expect(2).assertEqual(result.rowCount); 476 result.close() 477 result = null 478 479 done(); 480 console.log(TAG + "************* testNotEqualTo0008 end *************"); 481 }) 482 483 /** 484 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0028 485 * @tc.name Normal test case of predicates, test "notEqualTo" for true field 486 * @tc.desc 1.Execute notEqualTo ('1', 1) 487 * 2.Query data 488 * 3.Execute notEqualTo ('1', Number.NaN) 489 * 4.Query data 490 */ 491 it('testNotEqualTo0009', 0, async function (done) { 492 console.log(TAG + "************* testNotEqualTo0009 start *************"); 493 494 let predicates1 = new data_relationalStore.RdbPredicates("AllDataType"); 495 predicates1.notEqualTo('1', 1); 496 let result1 = await rdbStore.query(predicates1); 497 expect(0).assertEqual(result1.rowCount) 498 result1.close() 499 result1 = null 500 501 let predicates2 = new data_relationalStore.RdbPredicates("AllDataType"); 502 predicates2.notEqualTo('1', Number.NaN); 503 let result2 = await rdbStore.query(predicates2); 504 expect(0).assertEqual(result2.rowCount) 505 result2.close() 506 result2 = null 507 508 done(); 509 console.log(TAG + "************* testNotEqualTo0009 end *************"); 510 }) 511 512 513 /** 514 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0030 515 * @tc.name Normal test case of predicates, test "isNull" for primLong value 516 * @tc.desc 1.Execute isNull ("primLongValue") 517 * 2.Query data 518 */ 519 it('testIsNull0001', 0, async function (done) { 520 console.log(TAG + "************* testIsNull001 start *************"); 521 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 522 predicates.isNull("primLongValue"); 523 let result = await rdbStore.query(predicates); 524 expect(3).assertEqual(result.rowCount); 525 result.close() 526 result = null 527 done(); 528 console.log(TAG + "************* testIsNull0001 end *************"); 529 }) 530 531 /** 532 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0031 533 * @tc.name Normal test case of predicates, test "isNull" for long value 534 * @tc.desc 1.Execute isNull ("longValue") 535 * 2.Query data 536 */ 537 it('testIsNull0002', 0, async function (done) { 538 console.log(TAG + "************* testIsNull0002 start *************"); 539 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 540 predicates.isNull("longValue"); 541 let result = await rdbStore.query(predicates); 542 expect(0).assertEqual(result.rowCount); 543 result.close() 544 result = null 545 done(); 546 console.log(TAG + "************* testIsNull0002 end *************"); 547 }) 548 549 /** 550 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0032 551 * @tc.name Normal test case of predicates, test "isNull" for string value 552 * @tc.desc 1.Execute isNull ("stringValue") 553 * 2.Query data 554 */ 555 it('testIsNull0003', 0, async function (done) { 556 console.log(TAG + "************* testIsNull0003 start *************"); 557 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 558 predicates.isNull("stringValue"); 559 let result = await rdbStore.query(predicates); 560 expect(0).assertEqual(result.rowCount); 561 result.close() 562 result = null 563 done(); 564 console.log(TAG + "************* testIsNull0003 end *************"); 565 }) 566 567 /** 568 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0033 569 * @tc.name Abnormal test case of predicates, test "isNull" for invalid param 570 * @tc.desc 1.Execute isNull ("stringValueX") 571 * 2.Query data 572 */ 573 it('testIsNull0004', 0, async function (done) { 574 console.log(TAG + "************* testIsNull0004 start *************"); 575 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 576 predicates.isNull("stringValueX"); 577 let result = await rdbStore.query(predicates); 578 expect(-1).assertEqual(result.rowCount); 579 result.close() 580 result = null 581 done(); 582 console.log(TAG + "************* testIsNull0004 end *************"); 583 }) 584 585 /** 586 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0040 587 * @tc.name Normal test case of predicates, test "isNotNull" for primlong value 588 * @tc.desc 1.Execute isNotNull ("primLongValue") 589 * 2.Query data 590 */ 591 it('testIsNotNull0001', 0, async function (done) { 592 console.log(TAG + "************* testIsNotNull0001 start *************"); 593 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 594 predicates.isNotNull("primLongValue"); 595 let result = await rdbStore.query(predicates); 596 expect(0).assertEqual(result.rowCount); 597 result.close() 598 result = null 599 done(); 600 console.log(TAG + "************* testIsNotNull0001 end *************"); 601 }) 602 603 /** 604 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0041 605 * @tc.name Normal test case of predicates, test "isNotNull" for long value 606 * @tc.desc 1.Execute isNotNull ("longValue") 607 * 2.Query data 608 */ 609 it('testIsNotNull0002', 0, async function (done) { 610 console.log(TAG + "************* testIsNotNull0002 start *************"); 611 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 612 predicates.isNotNull("longValue"); 613 let result = await rdbStore.query(predicates); 614 expect(3).assertEqual(result.rowCount); 615 result.close() 616 result = null 617 done(); 618 console.log(TAG + "************* testIsNotNull0002 end *************"); 619 }) 620 621 /** 622 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0042 623 * @tc.name Normal test case of predicates, test "isNotNull" for string value 624 * @tc.desc 1.Execute isNotNull ("stringValue") 625 * 2.Query data 626 */ 627 it('testIsNotNull0003', 0, async function (done) { 628 console.log(TAG + "************* testIsNotNull0003 start *************"); 629 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 630 predicates.isNotNull("stringValue"); 631 let result = await rdbStore.query(predicates); 632 expect(3).assertEqual(result.rowCount); 633 result.close() 634 result = null 635 done(); 636 console.log(TAG + "************* testIsNotNull0003 end *************"); 637 }) 638 639 /** 640 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0043 641 * @tc.name Abnormal test case of predicates, test "isNotNull" for invalid param 642 * @tc.desc 1.Execute isNotNull ("stringValueX") 643 * 2.Query data 644 */ 645 it('testIsNotNull0004', 0, async function (done) { 646 console.log(TAG + "************* testIsNotNull0004 start *************"); 647 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 648 predicates.isNotNull("stringValueX"); 649 let result = await rdbStore.query(predicates); 650 expect(-1).assertEqual(result.rowCount); 651 result.close() 652 result = null 653 done(); 654 console.log(TAG + "************* testIsNotNull0004 end *************"); 655 }) 656 657 /** 658 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0050 659 * @tc.name Normal test case of predicates, test "greaterThan" for string value 660 * @tc.desc 1.Execute greaterThan ("stringValue", "ABC") 661 * 2.Query data 662 */ 663 it('testGreaterThan0001', 0, async function (done) { 664 console.log(TAG + "************* testGreaterThan0001 start *************"); 665 666 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 667 predicates.greaterThan("stringValue", "ABC"); 668 let result = await rdbStore.query(predicates); 669 expect(3).assertEqual(result.rowCount); 670 result.close() 671 result = null 672 673 done(); 674 console.log(TAG + "************* testGreaterThan0001 end *************"); 675 }) 676 677 /** 678 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0051 679 * @tc.name Normal test case of predicates, test "greaterThan" for double value 680 * @tc.desc 1.Execute greaterThan ("doubleValue", 0.0) 681 * 2.Query data 682 */ 683 it('testGreaterThan0002', 0, async function (done) { 684 console.log(TAG + "************* testGreaterThan0002 start *************"); 685 686 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 687 predicates.greaterThan("doubleValue", 0.0); 688 let result = await rdbStore.query(predicates); 689 expect(3).assertEqual(result.rowCount); 690 result.close() 691 result = null 692 693 done(); 694 console.log(TAG + "************* testGreaterThan0002 end *************"); 695 }) 696 697 /** 698 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0052 699 * @tc.name Normal test case of predicates, test "greaterThan" for integer value 700 * @tc.desc 1.Execute greaterThan ("integerValue", 1) 701 * 2.Query data 702 */ 703 it('testGreaterThan0003', 0, async function (done) { 704 console.log(TAG + "************* testGreaterThan0003 start *************"); 705 706 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 707 predicates.greaterThan("integerValue", 1); 708 let result = await rdbStore.query(predicates); 709 expect(1).assertEqual(result.rowCount); 710 result.close() 711 result = null 712 713 done(); 714 console.log(TAG + "************* testGreaterThan0003 end *************"); 715 }) 716 717 /** 718 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0053 719 * @tc.name Normal test case of predicates, test "greaterThan" for long value 720 * @tc.desc 1.Execute greaterThan ("longValue", 1) 721 * 2.Query data 722 */ 723 it('testGreaterThan0004', 0, async function (done) { 724 console.log(TAG + "************* testGreaterThan0004 start *************"); 725 726 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 727 predicates.greaterThan("longValue", 1); 728 let result = await rdbStore.query(predicates); 729 expect(1).assertEqual(result.rowCount); 730 result.close() 731 result = null 732 733 done(); 734 console.log(TAG + "************* testGreaterThan0004 end *************"); 735 }) 736 737 /** 738 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0054 739 * @tc.name Normal test case of predicates, test "greaterThan" for string value 740 * @tc.desc 1.Execute greaterThan ("stringValue", "ZZZ") 741 * 2.Query data 742 */ 743 it('testGreaterThan0005', 0, async function (done) { 744 console.log(TAG + "************* testGreaterThan0005 start *************"); 745 746 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 747 predicates.greaterThan("stringValue", "ZZZ"); 748 let result = await rdbStore.query(predicates); 749 expect(0).assertEqual(result.rowCount); 750 result.close() 751 result = null 752 753 done(); 754 console.log(TAG + "************* testGreaterThan0005 end *************"); 755 }) 756 757 /** 758 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0055 759 * @tc.name Normal test case of predicates, test "greaterThan" for double value 760 * @tc.desc 1.Execute greaterThan ("doubleValue", 999.0) 761 * 2.Query data 762 */ 763 it('testGreaterThan0006', 0, async function (done) { 764 console.log(TAG + "************* testGreaterThan0006 start *************"); 765 766 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 767 predicates.greaterThan("doubleValue", 999.0); 768 let result = await rdbStore.query(predicates); 769 expect(1).assertEqual(result.rowCount); 770 result.close() 771 result = null 772 773 done(); 774 console.log(TAG + "************* testGreaterThan0006 end *************"); 775 }) 776 777 /** 778 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0056 779 * @tc.name Normal test case of predicates, test "greaterThan" for integer value 780 * @tc.desc 1.Execute greaterThan ("integerValue", -999) 781 * 2.Query data 782 */ 783 it('testGreaterThan0007', 0, async function (done) { 784 console.log(TAG + "************* testGreaterThan0007 start *************"); 785 786 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 787 predicates.greaterThan("integerValue", -999); 788 let result = await rdbStore.query(predicates); 789 expect(2).assertEqual(result.rowCount); 790 result.close() 791 result = null 792 793 done(); 794 console.log(TAG + "************* testGreaterThan0007 end *************"); 795 }) 796 797 /** 798 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0057 799 * @tc.name Normal test case of predicates, test "greaterThan" for long value 800 * @tc.desc 1.Execute greaterThan ("longValue", -999) 801 * 2.Query data 802 */ 803 it('testGreaterThan0008', 0, async function (done) { 804 console.log(TAG + "************* testGreaterThan0008 start *************"); 805 806 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 807 predicates.greaterThan("longValue", -999); 808 let result = await rdbStore.query(predicates); 809 expect(2).assertEqual(result.rowCount); 810 result.close() 811 result = null 812 813 done(); 814 console.log(TAG + "************* testGreaterThan0008 end *************"); 815 }) 816 817 /** 818 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0058 819 * @tc.name Normal test case of predicates, test "greaterThan" for boundary value of longValue 820 * @tc.desc 1.Execute greaterThan ("longValue", Number.NaN) 821 * 2.Execute greaterThan ("longValue", Number.NEGATIVE_INFINITY) 822 * 3.Execute greaterThan ("longValue", Number.POSITIVE_INFINITY) 823 * 4.Execute greaterThan ("longValue", Number.MIN_SAFE_INTEGER) 824 * 5.Execute greaterThan ("longValue", Number.MAX_SAFE_INTEGER) 825 */ 826 it('testGreaterThan0009', 0, async function (done) { 827 console.log(TAG + "************* testGreaterThan0009 start *************"); 828 829 let predicates1 = new data_relationalStore.RdbPredicates("AllDataType"); 830 predicates1.greaterThan("longValue", Number.NaN); 831 let result1 = await rdbStore.query(predicates1); 832 expect(0).assertEqual(result1.rowCount); 833 result1.close() 834 result1 = null 835 836 let predicates2 = new data_relationalStore.RdbPredicates("AllDataType"); 837 predicates2.greaterThan("longValue", Number.NEGATIVE_INFINITY); 838 let result2 = await rdbStore.query(predicates2); 839 expect(3).assertEqual(result2.rowCount); 840 result2.close() 841 result2 = null 842 843 let predicates3 = new data_relationalStore.RdbPredicates("AllDataType"); 844 predicates3.greaterThan("longValue", Number.POSITIVE_INFINITY); 845 let result3 = await rdbStore.query(predicates3); 846 expect(0).assertEqual(result3.rowCount); 847 result3.close() 848 result3 = null 849 850 let predicates4 = new data_relationalStore.RdbPredicates("AllDataType"); 851 predicates4.greaterThan("longValue", Number.MIN_SAFE_INTEGER); 852 let result4 = await rdbStore.query(predicates4); 853 expect(2).assertEqual(result4.rowCount); 854 result4.close() 855 result4 = null 856 857 let predicates5 = new data_relationalStore.RdbPredicates("AllDataType"); 858 predicates5.greaterThan("longValue", Number.MAX_SAFE_INTEGER); 859 let result5 = await rdbStore.query(predicates5); 860 expect(1).assertEqual(result5.rowCount); 861 result5.close() 862 result5 = null 863 864 done(); 865 console.log(TAG + "************* testGreaterThan0009 end *************"); 866 }) 867 868 869 /** 870 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0060 871 * @tc.name Normal test case of predicates, test "greaterThanOrEqualTo" for string value 872 * @tc.desc 1.Execute greaterThanOrEqualTo ("stringValue", "ABC") 873 * 2.Query data 874 */ 875 it('testGreaterThanOrEqualTo0001', 0, async function (done) { 876 console.log(TAG + "************* testGreaterThanOrEqualTo0001 start *************"); 877 878 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 879 predicates.greaterThanOrEqualTo("stringValue", "ABC"); 880 let result = await rdbStore.query(predicates); 881 expect(3).assertEqual(result.rowCount); 882 result.close() 883 result = null 884 885 done(); 886 console.log(TAG + "************* testGreaterThanOrEqualTo0001 end *************"); 887 }) 888 889 /** 890 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0061 891 * @tc.name Normal test case of predicates, test "greaterThanOrEqualTo" for double value 892 * @tc.desc 1.Execute greaterThanOrEqualTo ("doubleValue", 0.0) 893 * 2.Query data 894 */ 895 it('testGreaterThanOrEqualTo0002', 0, async function (done) { 896 console.log(TAG + "************* testGreaterThanOrEqualTo0002 start *************"); 897 898 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 899 predicates.greaterThanOrEqualTo("doubleValue", 0.0); 900 let result = await rdbStore.query(predicates); 901 expect(3).assertEqual(result.rowCount); 902 result.close() 903 result = null 904 905 done(); 906 console.log(TAG + "************* testGreaterThanOrEqualTo0002 end *************"); 907 }) 908 909 /** 910 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0062 911 * @tc.name Normal test case of predicates, test "greaterThanOrEqualTo" for integer value 912 * @tc.desc 1.Execute greaterThanOrEqualTo ("integerValue", 1) 913 * 2.Query data 914 */ 915 it('testGreaterThanOrEqualTo0003', 0, async function (done) { 916 console.log(TAG + "************* testGreaterThanOrEqualTo0003 start *************"); 917 918 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 919 predicates.greaterThanOrEqualTo("integerValue", 1); 920 let result = await rdbStore.query(predicates); 921 expect(2).assertEqual(result.rowCount); 922 result.close() 923 result = null 924 925 done(); 926 console.log(TAG + "************* testGreaterThanOrEqualTo0003 end *************"); 927 }) 928 929 /** 930 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0063 931 * @tc.name Normal test case of predicates, test "greaterThanOrEqualTo" for long value 932 * @tc.desc 1.Execute greaterThanOrEqualTo ("longValue", 1) 933 * 2.Query data 934 */ 935 it('testGreaterThanOrEqualTo0004', 0, async function (done) { 936 console.log(TAG + "************* testGreaterThanOrEqualTo0004 start *************"); 937 938 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 939 predicates.greaterThanOrEqualTo("longValue", 1); 940 let result = await rdbStore.query(predicates); 941 expect(2).assertEqual(result.rowCount); 942 result.close() 943 result = null 944 945 done(); 946 console.log(TAG + "************* testGreaterThanOrEqualTo0004 end *************"); 947 }) 948 949 /** 950 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0070 951 * @tc.name Normal test case of predicates, test "lessThan" for string value 952 * @tc.desc 1.Execute lessThan ("stringValue", "ABD") 953 * 2.Query data 954 */ 955 it('testLessThan0001', 0, async function (done) { 956 console.log(TAG + "************* testLessThan0001 start *************"); 957 958 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 959 predicates.lessThan("stringValue", "ABD"); 960 let result = await rdbStore.query(predicates); 961 expect(3).assertEqual(result.rowCount); 962 result.close() 963 result = null 964 965 done(); 966 console.log(TAG + "************* testLessThan0001 end *************"); 967 }) 968 969 /** 970 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0071 971 * @tc.name Normal test case of predicates, test "lessThan" for double value 972 * @tc.desc 1.Execute lessThan ("doubleValue", 0.0) 973 * 2.Query data 974 */ 975 it('testLessThan0002', 0, async function (done) { 976 console.log(TAG + "************* testLessThan0002 start *************"); 977 978 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 979 predicates.lessThan("doubleValue", 0.0); 980 let result = await rdbStore.query(predicates); 981 expect(0).assertEqual(result.rowCount); 982 result.close() 983 result = null 984 985 done(); 986 console.log(TAG + "************* testLessThan0002 end *************"); 987 }) 988 989 /** 990 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0072 991 * @tc.name Normal test case of predicates, test "lessThan" for integer value 992 * @tc.desc 1.Execute lessThan ("integerValue", 1) 993 * 2.Query data 994 */ 995 it('testLessThan0003', 0, async function (done) { 996 console.log(TAG + "************* testLessThan0003 start *************"); 997 998 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 999 predicates.lessThan("integerValue", 1); 1000 let result = await rdbStore.query(predicates); 1001 expect(1).assertEqual(result.rowCount); 1002 result.close() 1003 result = null 1004 1005 done(); 1006 console.log(TAG + "************* testLessThan0003 end *************"); 1007 }) 1008 1009 /** 1010 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0073 1011 * @tc.name Normal test case of predicates, test "lessThan" for long value 1012 * @tc.desc 1.Execute lessThan ("longValue", 1) 1013 * 2.Query data 1014 */ 1015 it('testLessThan0004', 0, async function (done) { 1016 console.log(TAG + "************* testLessThan0004 start *************"); 1017 1018 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1019 predicates.lessThan("longValue", 1); 1020 let result = await rdbStore.query(predicates); 1021 expect(1).assertEqual(result.rowCount); 1022 result.close() 1023 result = null 1024 1025 done(); 1026 console.log(TAG + "************* testLessThan0004 end *************"); 1027 }) 1028 1029 /** 1030 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0074 1031 * @tc.name Normal test case of predicates, test "lessThan" for string value 1032 * @tc.desc 1.Execute lessThan ("stringValue", "ABD") 1033 * 2.Query data 1034 */ 1035 it('testLessThan0005', 0, async function (done) { 1036 console.log(TAG + "************* testLessThan0005 start *************"); 1037 1038 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1039 predicates.lessThan("stringValue", "ABD"); 1040 let result = await rdbStore.query(predicates); 1041 expect(3).assertEqual(result.rowCount); 1042 result.close() 1043 result = null 1044 1045 done(); 1046 console.log(TAG + "************* testLessThan0005 end *************"); 1047 }) 1048 1049 /** 1050 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0075 1051 * @tc.name Normal test case of predicates, test "lessThan" for double value 1052 * @tc.desc 1.Execute lessThan ("doubleValue", 1.0) 1053 * 2.Query data 1054 */ 1055 it('testLessThan0006', 0, async function (done) { 1056 console.log(TAG + "************* testLessThan0006 start *************"); 1057 1058 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1059 predicates.lessThan("doubleValue", 1.0); 1060 let result = await rdbStore.query(predicates); 1061 expect(1).assertEqual(result.rowCount); 1062 result.close() 1063 result = null 1064 1065 done(); 1066 console.log(TAG + "************* testLessThan0006 end *************"); 1067 }) 1068 1069 /** 1070 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0076 1071 * @tc.name Normal test case of predicates, test "lessThan" for boundary value of integerValue 1072 * @tc.desc 1.Execute lessThan ("integerValue", -2147483648) 1073 * 2.Query data 1074 */ 1075 it('testLessThan0007', 0, async function (done) { 1076 console.log(TAG + "************* testLessThan0007 start *************"); 1077 1078 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1079 predicates.lessThan("integerValue", -2147483648); 1080 let result = await rdbStore.query(predicates); 1081 expect(0).assertEqual(result.rowCount); 1082 result.close() 1083 result = null 1084 1085 done(); 1086 console.log(TAG + "************* testLessThan0007 end *************"); 1087 }) 1088 1089 /** 1090 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0077 1091 * @tc.name Normal test case of predicates, test "lessThan" for boundary value of longValue 1092 * @tc.desc 1.Execute lessThan ("longValue", -9223372036854775808) 1093 * 2.Query data 1094 */ 1095 it('testLessThan0008', 0, async function (done) { 1096 console.log(TAG + "************* testLessThan0008 start *************"); 1097 1098 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1099 predicates.lessThan("longValue", -9223372036854775808); 1100 let result = await rdbStore.query(predicates); 1101 expect(0).assertEqual(result.rowCount); 1102 result.close() 1103 result = null 1104 1105 done(); 1106 console.log(TAG + "************* testLessThan0008 end *************"); 1107 }) 1108 1109 /** 1110 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0080 1111 * @tc.name Normal test case of predicates, test "lessThanOrEqualTo" for string value 1112 * @tc.desc 1.Execute lessThanOrEqualTo ("stringValue", "ABD") 1113 * 2.Query data 1114 */ 1115 it('testLessThanOrEqualTo0001', 0, async function (done) { 1116 console.log(TAG + "************* testLessThanOrEqualTo0001 start *************"); 1117 1118 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1119 predicates.lessThanOrEqualTo("stringValue", "ABD"); 1120 let result = await rdbStore.query(predicates); 1121 expect(3).assertEqual(result.rowCount); 1122 result.close() 1123 result = null 1124 1125 done(); 1126 console.log(TAG + "************* testLessThanOrEqualTo0001 end *************"); 1127 }) 1128 1129 /** 1130 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0081 1131 * @tc.name Normal test case of predicates, test "lessThanOrEqualTo" for double value 1132 * @tc.desc 1.Execute lessThanOrEqualTo ("doubleValue", 0.0) 1133 * 2.Query data 1134 */ 1135 it('testLessThanOrEqualTo0002', 0, async function (done) { 1136 console.log(TAG + "************* testLessThanOrEqualTo0002 start *************"); 1137 1138 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1139 predicates.lessThanOrEqualTo("doubleValue", 0.0); 1140 let result = await rdbStore.query(predicates); 1141 expect(0).assertEqual(result.rowCount); 1142 result.close() 1143 result = null 1144 1145 done(); 1146 console.log(TAG + "************* testLessThanOrEqualTo0002 end *************"); 1147 }) 1148 1149 /** 1150 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0082 1151 * @tc.name Normal test case of predicates, test "lessThanOrEqualTo" for integer value 1152 * @tc.desc 1.Execute lessThanOrEqualTo ("integerValue", 1) 1153 * 2.Query data 1154 */ 1155 it('testLessThanOrEqualTo0003', 0, async function (done) { 1156 console.log(TAG + "************* testLessThanOrEqualTo0003 start *************"); 1157 1158 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1159 predicates.lessThanOrEqualTo("integerValue", 1); 1160 let result = await rdbStore.query(predicates); 1161 expect(2).assertEqual(result.rowCount); 1162 result.close() 1163 result = null 1164 1165 done(); 1166 console.log(TAG + "************* testLessThanOrEqualTo0003 end *************"); 1167 }) 1168 1169 /** 1170 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0083 1171 * @tc.name Normal test case of predicates, test "lessThanOrEqualTo" for long value 1172 * @tc.desc 1.Execute lessThanOrEqualTo ("longValue", 1) 1173 * 2.Query data 1174 */ 1175 it('testLessThanOrEqualTo0004', 0, async function (done) { 1176 console.log(TAG + "************* testLessThanOrEqualTo0004 start *************"); 1177 1178 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1179 predicates.lessThanOrEqualTo("longValue", 1); 1180 let result = await rdbStore.query(predicates); 1181 expect(2).assertEqual(result.rowCount); 1182 result.close() 1183 result = null 1184 1185 done(); 1186 console.log(TAG + "************* testLessThanOrEqualTo0004 end *************"); 1187 }) 1188 1189 /** 1190 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0084 1191 * @tc.name Normal test case of predicates, test "lessThanOrEqualTo" for boundary value of longValue 1192 * @tc.desc 1.Execute lessThanOrEqualTo ("longValue", Number.NaN) 1193 * 2.Execute lessThanOrEqualTo ("longValue", Number.NEGATIVE_INFINITY) 1194 * 3.Execute lessThanOrEqualTo ("longValue", Number.POSITIVE_INFINITY) 1195 * 4.Execute lessThanOrEqualTo ("longValue", Number.MAX_VALUE) 1196 * 5.Execute lessThanOrEqualTo ("longValue", Number.MIN_VALUE) 1197 */ 1198 it('testLessThanOrEqualTo0005', 0, async function (done) { 1199 console.log(TAG + "************* testLessThanOrEqualTo0005 start *************"); 1200 1201 let predicates1 = new data_relationalStore.RdbPredicates("AllDataType"); 1202 predicates1.lessThanOrEqualTo("longValue", Number.NaN); 1203 let result1 = await rdbStore.query(predicates1); 1204 expect(0).assertEqual(result1.rowCount); 1205 result1.close() 1206 result1 = null 1207 1208 let predicates2 = new data_relationalStore.RdbPredicates("AllDataType"); 1209 predicates2.lessThanOrEqualTo("longValue", Number.NEGATIVE_INFINITY); 1210 let result2 = await rdbStore.query(predicates2); 1211 expect(0).assertEqual(result2.rowCount); 1212 result2.close() 1213 result2 = null 1214 1215 let predicates3 = new data_relationalStore.RdbPredicates("AllDataType"); 1216 predicates3.lessThanOrEqualTo("longValue", Number.POSITIVE_INFINITY); 1217 let result3 = await rdbStore.query(predicates3); 1218 expect(3).assertEqual(result3.rowCount); 1219 result3.close() 1220 result3 = null 1221 1222 let predicates4 = new data_relationalStore.RdbPredicates("AllDataType"); 1223 predicates4.lessThanOrEqualTo("longValue", Number.MAX_VALUE); 1224 let result4 = await rdbStore.query(predicates4); 1225 expect(3).assertEqual(result4.rowCount); 1226 result4.close() 1227 result4 = null 1228 1229 let predicates5 = new data_relationalStore.RdbPredicates("AllDataType"); 1230 predicates5.lessThanOrEqualTo("longValue", Number.MIN_VALUE); 1231 let result5 = await rdbStore.query(predicates5); 1232 expect(1).assertEqual(result5.rowCount); 1233 result5.close() 1234 result5 = null 1235 1236 done(); 1237 console.log(TAG + "************* testLessThanOrEqualTo0005 end *************"); 1238 }) 1239 1240 /** 1241 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0090 1242 * @tc.name Normal test case of predicates, test "between" for string value 1243 * @tc.desc 1.Execute between ("stringValue", "ABB", "ABD") 1244 * 2.Query data 1245 */ 1246 it('testBetween0001', 0, async function (done) { 1247 console.log(TAG + "************* testBetween0001 start *************"); 1248 1249 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1250 predicates.between("stringValue", "ABB", "ABD"); 1251 let result = await rdbStore.query(predicates); 1252 expect(3).assertEqual(result.rowCount); 1253 result.close() 1254 result = null 1255 1256 done(); 1257 console.log(TAG + "************* testBetween0001 end *************"); 1258 }) 1259 1260 /** 1261 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0091 1262 * @tc.name Normal test case of predicates, test "between" for double value 1263 * @tc.desc 1.Execute between ("doubleValue", 0.0, DOUBLE_MAX) 1264 * 2.Query data 1265 */ 1266 it('testBetween0002', 0, async function (done) { 1267 console.log(TAG + "************* testBetween0002 start *************"); 1268 1269 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1270 predicates.between("doubleValue", 0.0, DOUBLE_MAX); 1271 let result = await rdbStore.query(predicates); 1272 expect(3).assertEqual(result.rowCount); 1273 result.close() 1274 result = null 1275 1276 done(); 1277 console.log(TAG + "************* testBetween0002 end *************"); 1278 }) 1279 1280 /** 1281 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0092 1282 * @tc.name Normal test case of predicates, test "between" for integer value 1283 * @tc.desc 1.Execute between ("integerValue", 0, 1) 1284 * 2.Query data 1285 */ 1286 it('testBetween0003', 0, async function (done) { 1287 console.log(TAG + "************* testBetween0003 start *************"); 1288 1289 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1290 predicates.between("integerValue", 0, 1); 1291 let result = await rdbStore.query(predicates); 1292 expect(1).assertEqual(result.rowCount); 1293 result.close() 1294 result = null 1295 1296 done(); 1297 console.log(TAG + "************* testBetween0003 end *************"); 1298 }) 1299 1300 /** 1301 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0093 1302 * @tc.name Normal test case of predicates, test "between" for long value 1303 * @tc.desc 1.Execute between ("longValue", 0, 2) 1304 * 2.Query data 1305 */ 1306 it('testBetween0004', 0, async function (done) { 1307 console.log(TAG + "************* testBetween0004 start *************"); 1308 1309 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1310 predicates.between("longValue", 0, 2); 1311 let result = await rdbStore.query(predicates); 1312 expect(1).assertEqual(result.rowCount); 1313 result.close() 1314 result = null 1315 1316 done(); 1317 console.log(TAG + "************* testBetween0004 end *************"); 1318 }) 1319 1320 /** 1321 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0094 1322 * @tc.name Normal test case of predicates, test "between" for string value 1323 * @tc.desc 1.Execute between ("stringValue", "ABB", "ABB") 1324 * 2.Query data 1325 */ 1326 it('testBetween0005', 0, async function (done) { 1327 console.log(TAG + "************* testBetween0005 start *************"); 1328 1329 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1330 predicates.between("stringValue", "ABB", "ABB"); 1331 let result = await rdbStore.query(predicates); 1332 expect(0).assertEqual(result.rowCount); 1333 result.close() 1334 result = null 1335 1336 done(); 1337 console.log(TAG + "************* testBetween0005 end *************"); 1338 }) 1339 1340 /** 1341 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0095 1342 * @tc.name Normal test case of predicates, test "between" for boundary value of doubleValue 1343 * @tc.desc 1.Execute between ("doubleValue", DOUBLE_MAX, DOUBLE_MAX) 1344 * 2.Query data 1345 */ 1346 it('testBetween0006', 0, async function (done) { 1347 console.log(TAG + "************* testBetween0006 start *************"); 1348 1349 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1350 predicates.between("doubleValue", DOUBLE_MAX, DOUBLE_MAX); 1351 let result = await rdbStore.query(predicates); 1352 expect(1).assertEqual(result.rowCount); 1353 result.close() 1354 result = null 1355 1356 done(); 1357 console.log(TAG + "************* testBetween0006 end *************"); 1358 }) 1359 1360 /** 1361 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0096 1362 * @tc.name Normal test case of predicates, test "between" for integer value 1363 * @tc.desc 1.Execute between ("integerValue", 1, 0) 1364 * 2.Query data 1365 */ 1366 it('testBetween0007', 0, async function (done) { 1367 console.log(TAG + "************* testBetween0007 start *************"); 1368 1369 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1370 predicates.between("integerValue", 1, 0); 1371 let result = await rdbStore.query(predicates); 1372 expect(0).assertEqual(result.rowCount); 1373 result.close() 1374 result = null 1375 1376 done(); 1377 console.log(TAG + "************* testBetween0007 end *************"); 1378 }) 1379 1380 /** 1381 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0097 1382 * @tc.name Normal test case of predicates, test "between" for long value 1383 * @tc.desc 1.Execute between ("longValue", 2, -1) 1384 * 2.Query data 1385 */ 1386 it('testBetween0008', 0, async function (done) { 1387 console.log(TAG + "************* testBetween0008 start *************"); 1388 1389 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1390 predicates.between("longValue", 2, -1); 1391 let result = await rdbStore.query(predicates); 1392 expect(0).assertEqual(result.rowCount); 1393 result.close() 1394 result = null 1395 1396 done(); 1397 console.log(TAG + "************* testBetween0008 end *************"); 1398 }) 1399 1400 /** 1401 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0098 1402 * @tc.name Normal test case of predicates, test "between" for boundary value of longValue 1403 * @tc.desc 1.Execute between ("longValue", 0, Number.POSITIVE_INFINITY) 1404 * 2.Execute between ("longValue", Number.NEGATIVE_INFINITY, 0) 1405 * 3.Execute between ("longValue", Number.NaN, 0) 1406 * 4.Execute between ("longValue", 0, Number.NaN) 1407 * 5.Execute between ("longValue", Number.MIN_VALUE, 0) 1408 */ 1409 it('testBetween0009', 0, async function (done) { 1410 console.log(TAG + "************* testBetween0009 start *************"); 1411 1412 let predicates1 = new data_relationalStore.RdbPredicates("AllDataType"); 1413 predicates1.between("longValue", 0, Number.POSITIVE_INFINITY); 1414 let result1 = await rdbStore.query(predicates1); 1415 expect(2).assertEqual(result1.rowCount); 1416 result1.close(); 1417 result1 = null 1418 1419 let predicates2 = new data_relationalStore.RdbPredicates("AllDataType"); 1420 predicates2.between("longValue", Number.NEGATIVE_INFINITY, 0); 1421 let result2 = await rdbStore.query(predicates2); 1422 expect(1).assertEqual(result2.rowCount); 1423 result2.close(); 1424 result2 = null 1425 1426 let predicates3 = new data_relationalStore.RdbPredicates("AllDataType"); 1427 predicates3.between("longValue", Number.NaN, 0); 1428 let result3 = await rdbStore.query(predicates3); 1429 expect(0).assertEqual(result3.rowCount); 1430 result3.close(); 1431 result3 = null 1432 1433 let predicates4 = new data_relationalStore.RdbPredicates("AllDataType"); 1434 predicates4.between("longValue", 0, Number.NaN); 1435 let result4 = await rdbStore.query(predicates4); 1436 expect(0).assertEqual(result4.rowCount); 1437 result4.close(); 1438 result4 = null 1439 1440 let predicates5 = new data_relationalStore.RdbPredicates("AllDataType"); 1441 predicates5.between("longValue", Number.MIN_VALUE, 0); 1442 let result5 = await rdbStore.query(predicates5); 1443 expect(0).assertEqual(result5.rowCount); 1444 result5.close(); 1445 result5 = null 1446 1447 let predicates6 = new data_relationalStore.RdbPredicates("AllDataType"); 1448 predicates6.between("longValue", 0, Number.MAX_VALUE); 1449 let result6 = await rdbStore.query(predicates6); 1450 expect(2).assertEqual(result6.rowCount); 1451 result6.close(); 1452 result6 = null 1453 1454 done(); 1455 console.log(TAG + "************* testBetween0009 end *************"); 1456 }) 1457 1458 /** 1459 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0100 1460 * @tc.name Normal test case of predicates, test "notBetween" for string value 1461 * @tc.desc 1.Execute notBetween ("stringValue", "ABB", "ABD") 1462 * 2.Query data 1463 */ 1464 it('testNotBetween0001', 0, async function (done) { 1465 console.log(TAG + "************* testNotBetween0001 start *************"); 1466 1467 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1468 predicates.notBetween("stringValue", "ABB", "ABD"); 1469 let result = await rdbStore.query(predicates); 1470 expect(0).assertEqual(result.rowCount); 1471 result.close(); 1472 result = null 1473 1474 done(); 1475 console.log(TAG + "************* testNotBetween0001 end *************"); 1476 }) 1477 1478 /** 1479 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0101 1480 * @tc.name Normal test case of predicates, test "notBetween" for double value 1481 * @tc.desc 1.Execute notBetween ("doubleValue", 0.0, DOUBLE_MAX) 1482 * 2.Query data 1483 */ 1484 it('testNotBetween0002', 0, async function (done) { 1485 console.log(TAG + "************* testNotBetween0002 start *************"); 1486 1487 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1488 predicates.notBetween("doubleValue", 0.0, DOUBLE_MAX); 1489 let result = await rdbStore.query(predicates); 1490 expect(0).assertEqual(result.rowCount); 1491 result.close(); 1492 result = null 1493 1494 done(); 1495 console.log(TAG + "************* testNotBetween0002 end *************"); 1496 }) 1497 1498 /** 1499 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0102 1500 * @tc.name Normal test case of predicates, test "notBetween" for integer value 1501 * @tc.desc 1.Execute notBetween ("integerValue", 0, 1) 1502 * 2.Query data 1503 */ 1504 it('testNotBetween0003', 0, async function (done) { 1505 console.log(TAG + "************* testNotBetween0003 start *************"); 1506 1507 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1508 predicates.notBetween("integerValue", 0, 1); 1509 let result = await rdbStore.query(predicates); 1510 expect(2).assertEqual(result.rowCount); 1511 result.close(); 1512 result = null 1513 1514 done(); 1515 console.log(TAG + "************* testNotBetween0003 end *************"); 1516 }) 1517 1518 /** 1519 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0103 1520 * @tc.name Normal test case of predicates, test "notBetween" for long value 1521 * @tc.desc 1.Execute notBetween ("longValue", 0, 2) 1522 * 2.Query data 1523 */ 1524 it('testNotBetween0004', 0, async function (done) { 1525 console.log(TAG + "************* testNotBetween0004 start *************"); 1526 1527 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1528 predicates.notBetween("longValue", 0, 2); 1529 let result = await rdbStore.query(predicates); 1530 expect(2).assertEqual(result.rowCount); 1531 result.close(); 1532 result = null 1533 1534 done(); 1535 console.log(TAG + "************* testNotBetween0004 end *************"); 1536 }) 1537 1538 /** 1539 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0104 1540 * @tc.name Normal test case of predicates, test "notBetween" for boundary value of longValue 1541 * @tc.desc 1.Execute notBetween ("longValue", 0, Number.NaN) 1542 * 2.Execute notBetween ("longValue", Number.NaN, 0) 1543 * 3.Execute notBetween ("longValue", Number.MIN_VALUE, 0) 1544 * 4.Execute notBetween ("longValue", 0, Number.MAX_VALUE) 1545 * 5.Execute notBetween ("longValue", Number.NEGATIVE_INFINITY, 0) 1546 * 6.Execute notBetween ("longValue", 0, Number.POSITIVE_INFINITY) 1547 */ 1548 it('testNotBetween0005', 0, async function (done) { 1549 console.log(TAG + "************* testNotBetween0005 start *************"); 1550 1551 let predicates1 = new data_relationalStore.RdbPredicates("AllDataType"); 1552 predicates1.notBetween("longValue", 0, Number.NaN); 1553 let result = await rdbStore.query(predicates1); 1554 expect(1).assertEqual(result.rowCount); 1555 result.close(); 1556 1557 let predicates2 = new data_relationalStore.RdbPredicates("AllDataType"); 1558 predicates2.notBetween("longValue", Number.NaN, 0); 1559 result = await rdbStore.query(predicates2); 1560 expect(2).assertEqual(result.rowCount); 1561 result.close(); 1562 1563 let predicates3 = new data_relationalStore.RdbPredicates("AllDataType"); 1564 predicates3.notBetween("longValue", Number.MIN_VALUE, 0); 1565 result = await rdbStore.query(predicates3); 1566 expect(3).assertEqual(result.rowCount); 1567 result.close(); 1568 1569 let predicates4 = new data_relationalStore.RdbPredicates("AllDataType"); 1570 predicates4.notBetween("longValue", 0, Number.MAX_VALUE); 1571 result = await rdbStore.query(predicates4); 1572 expect(1).assertEqual(result.rowCount); 1573 result.close(); 1574 1575 let predicates5 = new data_relationalStore.RdbPredicates("AllDataType"); 1576 predicates5.notBetween("longValue", Number.NEGATIVE_INFINITY, 0); 1577 result = await rdbStore.query(predicates5); 1578 expect(2).assertEqual(result.rowCount); 1579 result.close(); 1580 1581 let predicates6 = new data_relationalStore.RdbPredicates("AllDataType"); 1582 predicates6.notBetween("longValue", 0, Number.POSITIVE_INFINITY); 1583 result = await rdbStore.query(predicates6); 1584 expect(1).assertEqual(result.rowCount); 1585 result.close(); 1586 result = null 1587 1588 done(); 1589 console.log(TAG + "************* testNotBetween0005 end *************"); 1590 }) 1591 1592 /** 1593 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0110 1594 * @tc.name Normal test case of predicates, test "glob" for string value 1595 * @tc.desc 1.Execute glob ("stringValue", "ABC*") 1596 * 2.Query data 1597 */ 1598 it('testGlob0001', 0, async function (done) { 1599 console.log(TAG + "************* testGlob0001 start *************"); 1600 1601 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1602 predicates.glob("stringValue", "ABC*"); 1603 let result = await rdbStore.query(predicates); 1604 expect(3).assertEqual(result.rowCount); 1605 result.close(); 1606 result = null 1607 1608 done(); 1609 console.log(TAG + "************* testGlob0001 end *************"); 1610 }) 1611 1612 /** 1613 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0111 1614 * @tc.name Normal test case of predicates, test "glob" for string value 1615 * @tc.desc 1.Execute glob ("stringValue", "*LMN") 1616 * 2.Query data 1617 */ 1618 it('testGlob0002', 0, async function (done) { 1619 console.log(TAG + "************* testGlob0002 start *************"); 1620 1621 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1622 predicates.glob("stringValue", "*LMN"); 1623 let result = await rdbStore.query(predicates); 1624 expect(3).assertEqual(result.rowCount); 1625 result.close(); 1626 result = null 1627 1628 done(); 1629 console.log(TAG + "************* testGlob0002 end *************"); 1630 }) 1631 1632 /** 1633 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0112 1634 * @tc.name Normal test case of predicates, test "glob" for string value 1635 * @tc.desc 1.Execute glob ("stringValue", "ABCDEFGHIJKLM?") 1636 * 2.Query data 1637 */ 1638 it('testGlob0003', 0, async function (done) { 1639 console.log(TAG + "************* testGlob0003 start *************"); 1640 1641 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1642 predicates.glob("stringValue", "ABCDEFGHIJKLM?"); 1643 let result = await rdbStore.query(predicates); 1644 expect(3).assertEqual(result.rowCount); 1645 result.close(); 1646 result = null 1647 1648 done(); 1649 console.log(TAG + "************* testGlob0003 end *************"); 1650 }) 1651 1652 /** 1653 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0113 1654 * @tc.name Normal test case of predicates, test "glob" for string value 1655 * @tc.desc 1.Execute glob ("stringValue", "?BCDEFGHIJKLMN") 1656 * 2.Query data 1657 */ 1658 it('testGlob0004', 0, async function (done) { 1659 console.log(TAG + "************* testGlob0004 start *************"); 1660 1661 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1662 predicates.glob("stringValue", "?BCDEFGHIJKLMN"); 1663 let result = await rdbStore.query(predicates); 1664 expect(3).assertEqual(result.rowCount); 1665 result.close(); 1666 result = null 1667 1668 done(); 1669 console.log(TAG + "************* testGlob0004 end *************"); 1670 }) 1671 1672 /** 1673 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0114 1674 * @tc.name Normal test case of predicates, test "glob" for string value 1675 * @tc.desc 1.Execute glob ("stringValue", "*FGHI*") 1676 * 2.Query data 1677 */ 1678 it('testGlob0005', 0, async function (done) { 1679 console.log(TAG + "************* testGlob0005 start *************"); 1680 1681 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1682 predicates.glob("stringValue", "*FGHI*"); 1683 let result = await rdbStore.query(predicates); 1684 expect(3).assertEqual(result.rowCount); 1685 result.close(); 1686 result = null 1687 1688 done(); 1689 console.log(TAG + "************* testGlob0005 end *************"); 1690 }) 1691 1692 /** 1693 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0115 1694 * @tc.name Normal test case of predicates, test "glob" for string value 1695 * @tc.desc 1.Execute glob ("stringValue", "?BCDEFGHIJKLM?") 1696 * 2.Query data 1697 */ 1698 it('testGlob0006', 0, async function (done) { 1699 console.log(TAG + "************* testGlob0006 start *************"); 1700 1701 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1702 predicates.glob("stringValue", "?BCDEFGHIJKLM?"); 1703 let result = await rdbStore.query(predicates); 1704 expect(3).assertEqual(result.rowCount); 1705 result.close(); 1706 result = null 1707 1708 done(); 1709 console.log(TAG + "************* testGlob0006 end *************"); 1710 }) 1711 1712 /** 1713 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0120 1714 * @tc.name Normal test case of predicates, test "contains" for string value 1715 * @tc.desc 1.Execute contains ("stringValue", "DEF") 1716 * 2.Query data 1717 */ 1718 it('testContains0001', 0, async function (done) { 1719 console.log(TAG + "************* testContains0001 start *************"); 1720 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1721 predicates.contains("stringValue", "DEF"); 1722 let result = await rdbStore.query(predicates); 1723 expect(3).assertEqual(result.rowCount); 1724 result.close() 1725 result = null 1726 done(); 1727 console.log(TAG + "************* testContains0001 end *************"); 1728 }) 1729 1730 /** 1731 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0121 1732 * @tc.name Normal test case of predicates, test "contains" for string value 1733 * @tc.desc 1.Execute contains ("stringValue", "DEFX") 1734 * 2.Query data 1735 */ 1736 it('testContains0002', 0, async function (done) { 1737 console.log(TAG + "************* testContains0002 start *************"); 1738 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1739 predicates.contains("stringValue", "DEFX"); 1740 let result = await rdbStore.query(predicates); 1741 expect(0).assertEqual(result.rowCount); 1742 result.close() 1743 result = null 1744 done(); 1745 console.log(TAG + "************* testContains0002 end *************"); 1746 }) 1747 1748 /** 1749 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0122 1750 * @tc.name Normal test case of predicates, test "contains" for Chinese character value 1751 * @tc.desc 1.Execute contains ("characterValue", "中") 1752 * 2.Query data 1753 */ 1754 it('testContains0003', 0, async function (done) { 1755 console.log(TAG + "************* testContains0003 start *************"); 1756 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1757 predicates.contains("characterValue", "中"); 1758 let result = await rdbStore.query(predicates); 1759 expect(1).assertEqual(result.rowCount); 1760 result.close() 1761 result = null 1762 done(); 1763 console.log(TAG + "************* testContains0003 end *************"); 1764 }) 1765 1766 /** 1767 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0123 1768 * @tc.name Normal test case of predicates, test "contains" for character value 1769 * @tc.desc 1.Execute contains ("characterValue", "#") 1770 * 2.Query data 1771 */ 1772 it('testContains0004', 0, async function (done) { 1773 console.log(TAG + "************* testContains0004 start *************"); 1774 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1775 predicates.contains("characterValue", "#"); 1776 let result = await rdbStore.query(predicates); 1777 expect(1).assertEqual(result.rowCount); 1778 result.close() 1779 result = null 1780 done(); 1781 console.log(TAG + "************* testContains0004 end *************"); 1782 }) 1783 1784 /** 1785 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0124 1786 * @tc.name Abnormal test case of predicates, test "contains" for character value 1787 * @tc.desc 1.Execute contains ("characterValue", null) 1788 * 2.Query data 1789 * 3.Execute contains ("characterValue", undefined) 1790 * 4.Query data 1791 */ 1792 it('testContains0005', 0, async function (done) { 1793 console.info(TAG, `************* testContains0005 start *************`); 1794 try { 1795 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1796 predicates.contains("characterValue", null); 1797 expect(null).assertFail(); 1798 done(); 1799 } catch (err) { 1800 console.error(TAG, `predicates.contains failed: err code=${err.code}, message=${err.message}`); 1801 expect("401").assertEqual(err.code); 1802 } 1803 1804 try { 1805 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1806 predicates.contains("characterValue", undefined); 1807 expect(null).assertFail(); 1808 done(); 1809 } catch (err) { 1810 console.error(TAG, `predicates.contains failed: err code=${err.code}, message=${err.message}`); 1811 expect("401").assertEqual(err.code); 1812 done(); 1813 } 1814 console.info(TAG, `************* testContains0005 end *************`); 1815 }) 1816 1817 /** 1818 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0130 1819 * @tc.name Normal test case of predicates, test "beginsWith" for character value 1820 * @tc.desc 1.Execute beginsWith ("stringValue", "ABC") 1821 * 2.Query data 1822 */ 1823 it('testBeginsWith0001', 0, async function (done) { 1824 console.log(TAG + "************* testBeginsWith0001 start *************"); 1825 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1826 predicates.beginsWith("stringValue", "ABC"); 1827 let result = await rdbStore.query(predicates); 1828 expect(3).assertEqual(result.rowCount); 1829 result.close() 1830 result = null 1831 done(); 1832 console.log(TAG + "************* testBeginsWith0001 end *************"); 1833 }) 1834 1835 /** 1836 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0131 1837 * @tc.name Normal test case of predicates, test "beginsWith" for character value 1838 * @tc.desc 1.Execute beginsWith ("stringValue", "ABCX") 1839 * 2.Query data 1840 */ 1841 it('testBeginsWith0002', 0, async function (done) { 1842 console.log(TAG + "************* testBeginsWith0002 start *************"); 1843 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1844 predicates.beginsWith("stringValue", "ABCX"); 1845 let result = await rdbStore.query(predicates); 1846 expect(0).assertEqual(result.rowCount); 1847 result.close() 1848 result = null 1849 done(); 1850 console.log(TAG + "************* testBeginsWith0002 end *************"); 1851 }) 1852 1853 /** 1854 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0132 1855 * @tc.name Normal test case of predicates, test "beginsWith" for Chinese character value 1856 * @tc.desc 1.Execute beginsWith ("characterValue", "中") 1857 * 2.Query data 1858 */ 1859 it('testBeginsWith0003', 0, async function (done) { 1860 console.log(TAG + "************* testBeginsWith0003 start *************"); 1861 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1862 predicates.beginsWith("characterValue", "中"); 1863 let result = await rdbStore.query(predicates); 1864 expect(1).assertEqual(result.rowCount); 1865 result.close() 1866 result = null 1867 done(); 1868 console.log(TAG + "************* testBeginsWith0003 end *************"); 1869 }) 1870 1871 /** 1872 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0133 1873 * @tc.name Normal test case of predicates, test "beginsWith" for character value 1874 * @tc.desc 1.Execute beginsWith ("characterValue", "#") 1875 * 2.Query data 1876 */ 1877 it('testBeginsWith0004', 0, async function (done) { 1878 console.log(TAG + "************* testBeginsWith0004 start *************"); 1879 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1880 predicates.beginsWith("characterValue", "#"); 1881 let result = await rdbStore.query(predicates); 1882 expect(1).assertEqual(result.rowCount); 1883 result.close() 1884 result = null 1885 done(); 1886 console.log(TAG + "************* testBeginsWith0004 end *************"); 1887 }) 1888 1889 /** 1890 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0140 1891 * @tc.name Normal test case of predicates, test "endsWith" for string value 1892 * @tc.desc 1.Execute endsWith ("stringValue", "LMN") 1893 * 2.Query data 1894 */ 1895 it('testEndsWith0001', 0, async function (done) { 1896 console.log(TAG + "************* testEndsWith0001 start *************"); 1897 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1898 predicates.endsWith("stringValue", "LMN"); 1899 let result = await rdbStore.query(predicates); 1900 expect(3).assertEqual(result.rowCount); 1901 result.close() 1902 result = null 1903 done(); 1904 console.log(TAG + "************* testEndsWith0001 end *************"); 1905 }) 1906 1907 /** 1908 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0141 1909 * @tc.name Normal test case of predicates, test "endsWith" for string value 1910 * @tc.desc 1.Execute endsWith ("stringValue", "LMNX") 1911 * 2.Query data 1912 */ 1913 it('testEndsWith0002', 0, async function (done) { 1914 console.log(TAG + "************* testEndsWith0002 start *************"); 1915 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1916 predicates.endsWith("stringValue", "LMNX"); 1917 let result = await rdbStore.query(predicates); 1918 expect(0).assertEqual(result.rowCount); 1919 result.close() 1920 result = null 1921 done(); 1922 console.log(TAG + "************* testEndsWith0002 end *************"); 1923 }) 1924 1925 /** 1926 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0142 1927 * @tc.name Normal test case of predicates, test "endsWith" for Chinese character value 1928 * @tc.desc 1.Execute endsWith ("characterValue", "中") 1929 * 2.Query data 1930 */ 1931 it('testEndsWith0003', 0, async function (done) { 1932 console.log(TAG + "************* testEndsWith0003 start *************"); 1933 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1934 predicates.endsWith("characterValue", "中"); 1935 let result = await rdbStore.query(predicates); 1936 expect(1).assertEqual(result.rowCount); 1937 result.close() 1938 result = null 1939 done(); 1940 console.log(TAG + "************* testEndsWith0003 end *************"); 1941 }) 1942 1943 /** 1944 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0143 1945 * @tc.name Normal test case of predicates, test "endsWith" for character value 1946 * @tc.desc 1.Execute endsWith ("characterValue", "#") 1947 * 2.Query data 1948 */ 1949 it('testEndsWith0004', 0, async function (done) { 1950 console.log(TAG + "************* testEndsWith0004 start *************"); 1951 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1952 predicates.endsWith("characterValue", "#"); 1953 let result = await rdbStore.query(predicates); 1954 expect(1).assertEqual(result.rowCount); 1955 result.close() 1956 result = null 1957 done(); 1958 console.log(TAG + "************* testEndsWith0004 end *************"); 1959 }) 1960 1961 /** 1962 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0150 1963 * @tc.name Normal test case of predicates, test "like" for string value 1964 * @tc.desc 1.Execute like ("stringValue", "%LMN%") 1965 * 2.Query data 1966 */ 1967 it('testLike0001', 0, async function (done) { 1968 console.log(TAG + "************* testLike0001 start *************"); 1969 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1970 predicates.like("stringValue", "%LMN%"); 1971 let result = await rdbStore.query(predicates); 1972 expect(3).assertEqual(result.rowCount); 1973 result.close() 1974 result = null 1975 done(); 1976 console.log(TAG + "************* testLike0001 end *************"); 1977 }) 1978 1979 /** 1980 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0151 1981 * @tc.name Normal test case of predicates, test "like" for string value 1982 * @tc.desc 1.Execute like ("stringValue", "%LMNX%") 1983 * 2.Query data 1984 */ 1985 it('testLike0002', 0, async function (done) { 1986 console.log(TAG + "************* testLike0002 start *************"); 1987 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 1988 predicates.like("stringValue", "%LMNX%"); 1989 let result = await rdbStore.query(predicates); 1990 expect(0).assertEqual(result.rowCount); 1991 result.close() 1992 result = null 1993 done(); 1994 console.log(TAG + "************* testLike0002 end *************"); 1995 }) 1996 1997 /** 1998 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0152 1999 * @tc.name Normal test case of predicates, test "like" for Chinese character value 2000 * @tc.desc 1.Execute like ("characterValue", "%中%") 2001 * 2.Query data 2002 */ 2003 it('testLike0003', 0, async function (done) { 2004 console.log(TAG + "************* testLike0003 start *************"); 2005 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2006 predicates.like("characterValue", "%中%"); 2007 let result = await rdbStore.query(predicates); 2008 expect(1).assertEqual(result.rowCount); 2009 result.close() 2010 result = null 2011 done(); 2012 console.log(TAG + "************* testLike0003 end *************"); 2013 }) 2014 2015 /** 2016 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0153 2017 * @tc.name Normal test case of predicates, test "like" for character value 2018 * @tc.desc 1.Execute like ("characterValue", "%#%") 2019 * 2.Query data 2020 */ 2021 it('testLike0004', 0, async function (done) { 2022 console.log(TAG + "************* testLike0004 start *************"); 2023 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2024 predicates.like("characterValue", "%#%"); 2025 let result = await rdbStore.query(predicates); 2026 expect(1).assertEqual(result.rowCount); 2027 result.close() 2028 result = null 2029 done(); 2030 console.log(TAG + "************* testLike0004 end *************"); 2031 }) 2032 2033 /** 2034 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0154 2035 * @tc.name Abnormal test case of predicates, test "like" for character value 2036 * @tc.desc 1.Execute like ("characterValue", null) 2037 * 2.Query data 2038 * 3.Execute like ("characterValue", undefined) 2039 * 4.Query data 2040 */ 2041 it('testLike0005', 0, async function (done) { 2042 console.info(TAG, `************* testLike0005 start *************`); 2043 try { 2044 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2045 predicates.like("characterValue", null); 2046 expect(null).assertFail(); 2047 done(); 2048 } catch (err) { 2049 console.error(TAG, `predicates.like failed: err code=${err.code}, message=${err.message}`); 2050 expect("401").assertEqual(err.code); 2051 } 2052 2053 try { 2054 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2055 predicates.like("characterValue", undefined); 2056 expect(null).assertEqual(); 2057 done(); 2058 } catch (err) { 2059 console.error(TAG, `predicates.like failed: err code=${err.code}, message=${err.message}`); 2060 expect("401").assertEqual(err.code); 2061 done(); 2062 } 2063 console.info(TAG, `************* testLike0005 end *************`); 2064 }) 2065 2066 /** 2067 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0160 2068 * @tc.name Normal test case of predicates, test "beginWrap" 2069 * @tc.desc 1.Execute equalTo().beginWrap().equalTo().or().equalTo().endWrap() 2070 * 2.Query data 2071 */ 2072 it('testBeginWrap0001', 0, async function (done) { 2073 console.log(TAG + "************* testBeginWrap0001 start *************"); 2074 2075 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2076 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN") 2077 .beginWrap() 2078 .equalTo("integerValue", 1) 2079 .or() 2080 .equalTo("integerValue", 2147483647) 2081 .endWrap(); 2082 let result = await rdbStore.query(predicates); 2083 expect(2).assertEqual(result.rowCount); 2084 result.close() 2085 result = null 2086 2087 done(); 2088 console.log(TAG + "************* testBeginWrap0001 end *************"); 2089 }) 2090 2091 /** 2092 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0161 2093 * @tc.name Normal test case of predicates, test "beginWrap" 2094 * @tc.desc 1.Execute equalTo().beginWrap().equalTo().endWrap() 2095 * 2.Query data 2096 */ 2097 it('testBeginWrap0002', 0, async function (done) { 2098 console.log(TAG + "************* testBeginWrap0002 start *************"); 2099 2100 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2101 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN") 2102 .beginWrap() 2103 .equalTo("characterValue", ' ') 2104 .endWrap(); 2105 let result = await rdbStore.query(predicates); 2106 expect(1).assertEqual(result.rowCount); 2107 result.close() 2108 result = null 2109 2110 done(); 2111 console.log(TAG + "************* testBeginWrap0002 end *************"); 2112 }) 2113 2114 /** 2115 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0162 2116 * @tc.name Normal test case of predicates, test "beginWrap" 2117 * @tc.desc 1.Execute equalTo().beginWrap().equalTo().endWrap() 2118 * 2.Query data 2119 */ 2120 it('testBeginWrap0003', 0, async function (done) { 2121 console.log(TAG + "************* testBeginWrap0003 start *************"); 2122 2123 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2124 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN") 2125 .beginWrap() 2126 .equalTo("characterValue", '中') 2127 .endWrap(); 2128 let result = await rdbStore.query(predicates); 2129 expect(1).assertEqual(result.rowCount); 2130 result = null 2131 2132 done(); 2133 console.log(TAG + "************* testBeginWrap0003 end *************"); 2134 }) 2135 2136 /** 2137 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0163 2138 * @tc.name Abnormal test case of predicates, test "beginWrap" without "beginWrap" 2139 * @tc.desc 1.Execute equalTo().equalTo().endWrap() 2140 * 2.Query data 2141 */ 2142 it('testBeginWrap0004', 0, async function (done) { 2143 console.log(TAG + "************* testBeginWrap0004 start *************"); 2144 2145 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2146 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN") 2147 .equalTo("characterValue", '中') 2148 .endWrap(); 2149 let result = await rdbStore.query(predicates); 2150 expect(-1).assertEqual(result.rowCount); 2151 result.close() 2152 result = null 2153 2154 done(); 2155 console.log(TAG + "************* testBeginWrap0004 end *************"); 2156 }) 2157 2158 /** 2159 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0164 2160 * @tc.name Abnormal test case of predicates, test "beginWrap" without "endWrap" 2161 * @tc.desc 1.Execute equalTo().beginWrap().equalTo() 2162 * 2.Query data 2163 */ 2164 it('testBeginWrap0005', 0, async function (done) { 2165 console.log(TAG + "************* testBeginWrap0005 start *************"); 2166 { 2167 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2168 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN") 2169 .beginWrap() 2170 .equalTo("characterValue", '中'); 2171 let result = await rdbStore.query(predicates); 2172 expect(-1).assertEqual(result.rowCount); 2173 result.close() 2174 result = null 2175 } 2176 done(); 2177 console.log(TAG + "************* testBeginWrap0005 end *************"); 2178 }) 2179 2180 /** 2181 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0170 2182 * @tc.name Normal test case of predicates, test "and" 2183 * @tc.desc 1.Execute equalTo().and().equalTo() 2184 * 2.Query data 2185 */ 2186 it('testAnd0001', 0, async function (done) { 2187 console.log(TAG + "************* testAnd0001 start *************"); 2188 2189 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2190 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN") 2191 .and() 2192 .equalTo("integerValue", 1); 2193 let result = await rdbStore.query(predicates); 2194 expect(1).assertEqual(result.rowCount); 2195 result.close() 2196 result = null 2197 2198 done(); 2199 console.log(TAG + "************* testAnd0001 end *************"); 2200 }) 2201 2202 /** 2203 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0171 2204 * @tc.name Normal test case of predicates, test "and" 2205 * @tc.desc 1.Execute equalTo().beginWrap().equalTo().or().equalTo().endWrap() 2206 * 2.Query data 2207 */ 2208 it('testAnd0002', 0, async function (done) { 2209 console.log(TAG + "************* testAnd0002 start *************"); 2210 2211 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2212 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN") 2213 .beginWrap() 2214 .equalTo("integerValue", 1) 2215 .or() 2216 .equalTo("integerValue", 2147483647) 2217 .endWrap(); 2218 let result = await rdbStore.query(predicates); 2219 expect(2).assertEqual(result.rowCount); 2220 result.close() 2221 result = null 2222 2223 done(); 2224 console.log(TAG + "************* testAnd0002 end *************"); 2225 }) 2226 2227 /** 2228 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0172 2229 * @tc.name Abnormal test case of predicates, test "and" 2230 * @tc.desc 1.Execute equalTo().or().and().equalTo() 2231 * 2.Query data 2232 */ 2233 it('testAnd0003', 0, async function (done) { 2234 console.log(TAG + "************* testAnd0003 start *************"); 2235 2236 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2237 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN").or().and().equalTo("integerValue", 1); 2238 console.log(TAG + "you should not start a request" + " with \"and\" or use or() before this function"); 2239 2240 done(); 2241 console.log(TAG + "************* testAnd0003 end *************"); 2242 }) 2243 2244 /** 2245 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0180 2246 * @tc.name Normal test case of predicates, test "orderByAsc" for integer value 2247 * @tc.desc 1.Execute orderByAsc ("integerValue") 2248 * 2.Query data 2249 */ 2250 it('testOrder0001', 0, async function (done) { 2251 console.log(TAG + "************* testOrder0001 start *************"); 2252 2253 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2254 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN").orderByAsc("integerValue").distinct(); 2255 let result = await rdbStore.query(predicates); 2256 expect(3).assertEqual(result.rowCount); 2257 expect(true).assertEqual(result.goToFirstRow()) 2258 expect(3).assertEqual(result.getLong(0)); 2259 expect(true).assertEqual(result.goToNextRow()) 2260 expect(2).assertEqual(result.getLong(0)); 2261 expect(true).assertEqual(result.goToNextRow()) 2262 expect(1).assertEqual(result.getLong(0)); 2263 result.close() 2264 result = null 2265 2266 done(); 2267 console.log(TAG + "************* testOrder0001 end *************"); 2268 }) 2269 2270 /** 2271 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0181 2272 * @tc.name Normal test case of predicates, test "orderByDesc" for integer value 2273 * @tc.desc 1.Execute orderByDesc ("integerValue") 2274 * 2.Query data 2275 */ 2276 it('testOrder0002', 0, async function (done) { 2277 console.log(TAG + "************* testOrder0002 start *************"); 2278 2279 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2280 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN").orderByDesc("integerValue").distinct(); 2281 let result = await rdbStore.query(predicates); 2282 expect(3).assertEqual(result.rowCount); 2283 expect(true).assertEqual(result.goToFirstRow()) 2284 expect(1).assertEqual(result.getLong(0)); 2285 expect(true).assertEqual(result.goToNextRow()) 2286 expect(2).assertEqual(result.getLong(0)); 2287 expect(true).assertEqual(result.goToNextRow()) 2288 expect(3).assertEqual(result.getLong(0)); 2289 result.close() 2290 result = null 2291 2292 done(); 2293 console.log(TAG + "************* testOrder0002 end *************"); 2294 }) 2295 2296 /** 2297 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0182 2298 * @tc.name Abnormal test case of predicates, test "orderByDesc" for invalid param 2299 * @tc.desc 1.Execute orderByDesc ("integerValueX") 2300 * 2.Query data 2301 */ 2302 it('testOrder0003', 0, async function (done) { 2303 console.log(TAG + "************* testOrder0003 start *************"); 2304 2305 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2306 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN").orderByDesc("integerValueX").distinct(); 2307 let result = await rdbStore.query(predicates); 2308 expect(-1).assertEqual(result.rowCount); 2309 result.close() 2310 result = null 2311 2312 done(); 2313 console.log(TAG + "************* testOrder0003 end *************"); 2314 }) 2315 2316 /** 2317 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0183 2318 * @tc.name Abnormal test case of predicates, test "orderByAsc" for invalid param 2319 * @tc.desc 1.Execute orderByAsc ("integerValueX") 2320 * 2.Query data 2321 */ 2322 it('testOrder0004', 0, async function (done) { 2323 console.log(TAG + "************* testOrder0004 start *************"); 2324 2325 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2326 predicates.equalTo("stringValue", "ABCDEFGHIJKLMN").orderByAsc("integerValueX").distinct(); 2327 let result = await rdbStore.query(predicates); 2328 expect(-1).assertEqual(result.rowCount); 2329 result.close() 2330 result = null 2331 2332 done(); 2333 console.log(TAG + "************* testOrder0004 end *************"); 2334 }) 2335 2336 /** 2337 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0190 2338 * @tc.name Normal test case of predicates, test "limitAs" '1' 2339 * @tc.desc 1.Execute limitAs 2340 * 2.Query data 2341 */ 2342 it('testLimit0001', 0, async function (done) { 2343 console.log(TAG + "************* testLimit0001 start *************"); 2344 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2345 predicates.like("stringValue", "ABCDEFGHIJKLMN").limitAs(1); 2346 let result = await rdbStore.query(predicates); 2347 expect(1).assertEqual(result.rowCount); 2348 result.close() 2349 result = null 2350 done(); 2351 console.log(TAG + "************* testLimit0001 end *************"); 2352 }) 2353 2354 /** 2355 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0191 2356 * @tc.name Normal test case of predicates, test "limitAs" '3' 2357 * @tc.desc 1.Execute limitAs 2358 * 2.Query data 2359 */ 2360 it('testLimit0002', 0, async function (done) { 2361 console.log(TAG + "************* testLimit0002 start *************"); 2362 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2363 predicates.like("stringValue", "ABCDEFGHIJKLMN").limitAs(3); 2364 let result = await rdbStore.query(predicates); 2365 expect(3).assertEqual(result.rowCount); 2366 result.close() 2367 result = null 2368 done(); 2369 console.log(TAG + "************* testLimit0002 end *************"); 2370 }) 2371 2372 /** 2373 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0192 2374 * @tc.name Normal test case of predicates, test "limitAs" "100" 2375 * @tc.desc 1.Execute limitAs 2376 * 2.Query data 2377 */ 2378 it('testLimit0003', 0, async function (done) { 2379 console.log(TAG + "************* testLimit0003 start *************"); 2380 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2381 predicates.like("stringValue", "ABCDEFGHIJKLMN").limitAs(100); 2382 let result = await rdbStore.query(predicates); 2383 expect(3).assertEqual(result.rowCount); 2384 result.close() 2385 result = null 2386 done(); 2387 console.log(TAG + "************* testLimit0003 end *************"); 2388 }) 2389 2390 /** 2391 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0193 2392 * @tc.name Normal test case of predicates, test "limitAs" for Chinese value 2393 * @tc.desc 1.Execute limitAs 2394 * 2.Query data 2395 */ 2396 it('testLimit0004', 0, async function (done) { 2397 console.log(TAG + "************* testLimit0004 start *************"); 2398 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2399 predicates.like("stringValue", "中").limitAs(1); 2400 let result = await rdbStore.query(predicates); 2401 expect(0).assertEqual(result.rowCount); 2402 result.close() 2403 result = null 2404 done(); 2405 console.log(TAG + "************* testLimit0004 end *************"); 2406 }) 2407 2408 /** 2409 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0194 2410 * @tc.name Normal test case of predicates, test "limitAs" '0' 2411 * @tc.desc 1.Execute limitAs 2412 * 2.Query data 2413 */ 2414 it('testLimit0005', 0, async function (done) { 2415 console.log(TAG + "************* testLimit0005 start *************"); 2416 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2417 predicates.like("stringValue", "ABCDEFGHIJKLMN").limitAs(0); 2418 let result = await rdbStore.query(predicates); 2419 expect(3).assertEqual(result.rowCount); 2420 result.close() 2421 result = null 2422 done(); 2423 console.log(TAG + "************* testLimit0005 end *************"); 2424 }) 2425 2426 /** 2427 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0195 2428 * @tc.name Normal test case of predicates, test "limitAs" "-1" 2429 * @tc.desc 1.Execute limitAs 2430 * 2.Query data 2431 */ 2432 it('testLimit0006', 0, async function (done) { 2433 console.log(TAG + "************* testLimit0006 start *************"); 2434 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2435 predicates.like("stringValue", "ABCDEFGHIJKLMN").limitAs(-1); 2436 let result = await rdbStore.query(predicates); 2437 expect(3).assertEqual(result.rowCount); 2438 result.close() 2439 result = null 2440 done(); 2441 console.log(TAG + "************* testLimit0006 end *************"); 2442 }) 2443 2444 /** 2445 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0196 2446 * @tc.name Normal test case of predicates, test "limitAs" 2447 * @tc.desc 1.Execute limitAs (-1) 2448 * 2.Execute limitAs (1, 1)) 2449 * 3.Execute limitAs (0, -1) 2450 * 4.Execute like ("stringValue", "ABCDEFGHIJKLMN") 2451 * 5.Execute orderByAsc ("id") 2452 * 6.Execute limitAs (-1, -1) 2453 */ 2454 it('testLimit0007', 0, async function (done) { 2455 console.log(TAG + "************* testLimit0007 start *************"); 2456 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2457 predicates.limitAs(-1); 2458 let result = await rdbStore.query(predicates); 2459 expect(3).assertEqual(result.rowCount); 2460 predicates.clear(); 2461 2462 predicates.limitAs(1, 1); 2463 result = await rdbStore.query(predicates); 2464 expect(1).assertEqual(result.rowCount); 2465 predicates.clear(); 2466 2467 predicates.limitAs(0, -1); 2468 result = await rdbStore.query(predicates); 2469 expect(3).assertEqual(result.rowCount); 2470 predicates.clear(); 2471 2472 predicates.like("stringValue", "ABCDEFGHIJKLMN") 2473 predicates.orderByAsc("id"); 2474 predicates.limitAs(-1, -1); 2475 result = await rdbStore.query(predicates); 2476 expect(3).assertEqual(result.rowCount); 2477 expect(" WHERE stringValue LIKE ? ORDER BY id ASC LIMIT -1 OFFSET -1").assertEqual(predicates.statement); 2478 expect("ABCDEFGHIJKLMN").assertEqual(predicates.bindArgs[0]); 2479 expect(true).assertEqual(result.goToFirstRow()) 2480 expect(1).assertEqual(result.getLong(0)); 2481 expect(2147483647).assertEqual(result.getLong(1)); 2482 expect(DOUBLE_MAX).assertEqual(result.getDouble(2)); 2483 result.close() 2484 result = null 2485 done(); 2486 console.log(TAG + "************* testLimit0007 end *************"); 2487 }) 2488 2489 /** 2490 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0200 2491 * @tc.name Normal test case of predicates, test "offsetAs" '1' 2492 * @tc.desc 1.Execute offsetAs 2493 * 2.Query data 2494 */ 2495 it('testOffset0001', 0, async function (done) { 2496 console.log(TAG + "************* testOffset0001 start *************"); 2497 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2498 predicates.like("stringValue", "ABCDEFGHIJKLMN").limitAs(3).offsetAs(1); 2499 let result = await rdbStore.query(predicates); 2500 expect(2).assertEqual(result.rowCount); 2501 result.close() 2502 result = null 2503 done(); 2504 console.log(TAG + "************* testOffset0001 end *************"); 2505 }) 2506 2507 /** 2508 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0201 2509 * @tc.name Normal test case of predicates, test "offsetAs" '0' 2510 * @tc.desc 1.Execute offsetAs 2511 * 2.Query data 2512 */ 2513 it('testOffset0002', 0, async function (done) { 2514 console.log(TAG + "************* testOffset0002 start *************"); 2515 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2516 predicates.like("stringValue", "ABCDEFGHIJKLMN").limitAs(3).offsetAs(0); 2517 let result = await rdbStore.query(predicates); 2518 expect(3).assertEqual(result.rowCount); 2519 result.close() 2520 result = null 2521 done(); 2522 console.log(TAG + "************* testOffset0002 end *************"); 2523 }) 2524 2525 /** 2526 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0202 2527 * @tc.name Normal test case of predicates, test "offsetAs" '5' 2528 * @tc.desc 1.Execute offsetAs 2529 * 2.Query data 2530 */ 2531 it('testOffset0003', 0, async function (done) { 2532 console.log(TAG + "************* testOffset0003 start *************"); 2533 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2534 predicates.like("stringValue", "ABCDEFGHIJKLMN").limitAs(3).offsetAs(5); 2535 let result = await rdbStore.query(predicates); 2536 expect(0).assertEqual(result.rowCount); 2537 result.close() 2538 result = null 2539 done(); 2540 console.log(TAG + "************* testOffset0003 end *************"); 2541 }) 2542 2543 /** 2544 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0203 2545 * @tc.name Normal test case of predicates, test "offsetAs" "-1" 2546 * @tc.desc 1.Execute offsetAs 2547 * 2.Query data 2548 */ 2549 it('testOffset0004', 0, async function (done) { 2550 console.log(TAG + "************* testOffset0004 start *************"); 2551 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2552 predicates.like("stringValue", "ABCDEFGHIJKLMN").limitAs(3).offsetAs(-1); 2553 let result = await rdbStore.query(predicates); 2554 expect(3).assertEqual(result.rowCount); 2555 result.close() 2556 result = null 2557 done(); 2558 console.log(TAG + "************* testOffset0004 end *************"); 2559 }) 2560 2561 /** 2562 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0210 2563 * @tc.name Normal test case of predicates, test "in" for boundary value of doubleValue 2564 * @tc.desc 1.Execute in ("doubleValue", Number.MIN_VALUE.toString()) 2565 * 2.Query data 2566 */ 2567 it('testIn0001', 0, async function (done) { 2568 console.log(TAG + "************* testIn0001 start *************"); 2569 var values = [Number.MIN_VALUE.toString()]; 2570 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2571 predicates.in("doubleValue", values); 2572 let result = await rdbStore.query(predicates); 2573 expect(1).assertEqual(result.rowCount); 2574 result.close() 2575 done(); 2576 console.log(TAG + "************* testIn0001 end *************"); 2577 }) 2578 2579 /** 2580 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0211 2581 * @tc.name Normal test case of predicates, test "in" for doubleValue 2582 * @tc.desc 1.Execute in ("doubleValue", "1.0") 2583 * 2.Query data 2584 */ 2585 it('testIn0002', 0, async function (done) { 2586 console.log(TAG + "************* testIn0002 start *************"); 2587 var values = ["1.0"]; 2588 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2589 predicates.in("doubleValue", values); 2590 let result = await rdbStore.query(predicates); 2591 expect(1).assertEqual(result.rowCount); 2592 result.close() 2593 done(); 2594 console.log(TAG + "************* testIn0002 end *************"); 2595 }) 2596 2597 /** 2598 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0212 2599 * @tc.name Normal test case of predicates, test "in" for boundary value of doubleValue 2600 * @tc.desc 1.Execute in ("doubleValue", DOUBLE_MAX.toString()) 2601 * 2.Query data 2602 */ 2603 it('testIn0003', 0, async function (done) { 2604 console.log(TAG + "************* testIn0003 start *************"); 2605 var values = [DOUBLE_MAX.toString()]; 2606 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2607 predicates.in("doubleValue", values); 2608 let result = await rdbStore.query(predicates); 2609 expect(1).assertEqual(result.rowCount); 2610 result.close() 2611 done(); 2612 console.log(TAG + "************* testIn0003 end *************"); 2613 }) 2614 2615 /** 2616 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0213 2617 * @tc.desc Normal test case of predicates, test "in" for boundary value of doubleValue 2618 * @tc.desc 1.Execute in ("doubleValue", Number.MIN_VALUE.toString(), "1.0", DOUBLE_MAX.toString()) 2619 * 2.Query data 2620 */ 2621 it('testIn0004', 0, async function (done) { 2622 console.log(TAG + "************* testIn0004 start *************"); 2623 var values = [Number.MIN_VALUE.toString(), "1.0", DOUBLE_MAX.toString()]; 2624 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2625 predicates.in("doubleValue", values); 2626 let result = await rdbStore.query(predicates); 2627 expect(3).assertEqual(result.rowCount); 2628 result.close() 2629 done(); 2630 console.log(TAG + "************* testIn0004 end *************"); 2631 }) 2632 2633 /** 2634 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0220 2635 * @tc.name Normal test case of predicates, test "notIn" for boundary value of integerValue 2636 * @tc.desc 1.Execute notIn ("integerValue", [1, -2147483648]) 2637 * 2.Query data 2638 */ 2639 it('testNotIn0001', 0, async function (done) { 2640 console.log(TAG + "************* testNotIn0001 start *************"); 2641 var values = [1, -2147483648]; 2642 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2643 predicates.notIn("integerValue", values); 2644 let result = await rdbStore.query(predicates); 2645 expect(1).assertEqual(result.rowCount); 2646 result.close(); 2647 done(); 2648 console.log(TAG + "************* testNotIn0001 end *************"); 2649 }) 2650 2651 /** 2652 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0221 2653 * @tc.name Normal test case of predicates, test "notIn" for boundary value of integerValue 2654 * @tc.desc 1.Execute notIn ("integerValue", [1, 2147483647]) 2655 * 2.Query data 2656 */ 2657 it('testNotIn0002', 0, async function (done) { 2658 console.log(TAG + "************* testNotIn0002 start *************"); 2659 let values = [1, 2147483647]; 2660 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2661 predicates.notIn("integerValue", values); 2662 let result = await rdbStore.query(predicates); 2663 expect(1).assertEqual(result.rowCount); 2664 result.close(); 2665 done(); 2666 console.log(TAG + "************* testNotIn0002 end *************"); 2667 }) 2668 2669 /** 2670 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0222 2671 * @tc.name Normal test case of predicates, test "notIn" for boundary value of integerValue 2672 * @tc.desc 1.Execute notIn ("integerValue", [-2147483648, 2147483647]) 2673 * 2.Query data 2674 */ 2675 it('testNotIn0003', 0, async function (done) { 2676 console.log(TAG + "************* testNotIn0003 start *************"); 2677 var values = [-2147483648, 2147483647]; 2678 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2679 predicates.notIn("integerValue", values); 2680 let result = await rdbStore.query(predicates); 2681 expect(1).assertEqual(result.rowCount); 2682 result.close(); 2683 done(); 2684 console.log(TAG + "************* testNotIn0003 end *************"); 2685 }) 2686 2687 /** 2688 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0230 2689 * @tc.name Normal test case of predicates, test "RdbPredicates" 2690 * @tc.desc 1.Execute RdbPredicates ("AllDataType") 2691 * 2.Query data 2692 */ 2693 it('testCreate0001', 0, async function (done) { 2694 console.log(TAG + "************* testCreate0001 start *************"); 2695 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2696 let result = await rdbStore.query(predicates); 2697 expect(3).assertEqual(result.rowCount); 2698 result.close() 2699 done(); 2700 console.log(TAG + "************* testCreate0001 end *************"); 2701 }) 2702 2703 /** 2704 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0231 2705 * @tc.name Abnormal test case of predicates, test "RdbPredicates" for creat new table 2706 * @tc.desc 1.Execute RdbPredicates ("test") 2707 * 2.Query data 2708 */ 2709 it('testCreate0002', 0, async function (done) { 2710 console.log(TAG + "************* testCreate0002 start *************"); 2711 let predicates = new data_relationalStore.RdbPredicates("test"); 2712 let result = await rdbStore.query(predicates); 2713 expect(-1).assertEqual(result.rowCount); 2714 result.close() 2715 done(); 2716 console.log(TAG + "************* testCreate0002 end *************"); 2717 }) 2718 2719 /** 2720 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0240 2721 * @tc.name Normal test case of predicates, test "groupBy" for character value 2722 * @tc.desc 1.Execute groupBy (["characterValue"]) 2723 * 2.Query data 2724 */ 2725 it('testGroupBy0001', 0, async function (done) { 2726 console.log(TAG + "************* testGroupBy0001 start *************"); 2727 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2728 predicates.like("stringValue", "ABCDEFGHIJKLMN").groupBy(["characterValue"]); 2729 let result = await rdbStore.query(predicates); 2730 expect(3).assertEqual(result.rowCount); 2731 result.close() 2732 result = null 2733 done(); 2734 console.log(TAG + "************* testGroupBy0001 end *************"); 2735 }) 2736 2737 /** 2738 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0241 2739 * @tc.name Abnormal test case of predicates, test "groupBy" for invalid param 2740 * @tc.desc 1.Execute groupBy (["characterValueX"]) 2741 * 2.Query data 2742 */ 2743 it('testGroupBy0002', 0, async function (done) { 2744 console.log(TAG + "************* testGroupBy0002 start *************"); 2745 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2746 predicates.like("stringValue", "ABCDEFGHIJKLMN").groupBy(["characterValueX"]); 2747 let result = await rdbStore.query(predicates); 2748 expect(-1).assertEqual(result.rowCount); 2749 result.close() 2750 result = null 2751 done(); 2752 console.log(TAG + "************* testGroupBy0002 end *************"); 2753 }) 2754 2755 /** 2756 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0250 2757 * @tc.name Abnormal test case of predicates, test "indexedBy" for character value 2758 * @tc.desc 1.Execute indexedBy ("characterValue") 2759 * 2.Query data 2760 */ 2761 it('testIndexedBy0001', 0, async function (done) { 2762 console.log(TAG + "************* testIndexedBy0001 start *************"); 2763 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2764 predicates.like("stringValue", "ABCDEFGHIJKLMN").indexedBy("characterValue"); 2765 let result = await rdbStore.query(predicates); 2766 //test table have no indexe column, so return -1 2767 expect(-1).assertEqual(result.rowCount); 2768 result.close() 2769 result = null 2770 done(); 2771 console.log(TAG + "************* testIndexedBy0001 end *************"); 2772 }) 2773 2774 /** 2775 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0251 2776 * @tc.name Abnormal test case of predicates, test "indexedBy" for invalid param 2777 * @tc.desc 1.Execute indexedBy (["characterValueX"]) 2778 * 2.Query data 2779 */ 2780 it('testIndexedBy0002', 0, async function (done) { 2781 console.log(TAG + "************* testIndexedBy0002 start *************"); 2782 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2783 try { 2784 predicates.like("stringValue", "ABCDEFGHIJKLMN").indexedBy(["characterValueX"]); 2785 let result = await rdbStore.query(predicates); 2786 expect(3).assertEqual(result.rowCount); 2787 result.close() 2788 result = null 2789 } catch (err) { 2790 console.log("catch err: failed, err: code=" + err.code + " message=" + err.message) 2791 expect("401").assertEqual(err.code) 2792 } 2793 done(); 2794 console.log(TAG + "************* testIndexedBy0002 end *************"); 2795 }) 2796 2797 /** 2798 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0260 2799 * @tc.name Abnormal test case of predicates, call system api 2800 * @tc.desc 1.Configure predicates 2801 * 2.Query data 2802 */ 2803 it('testQueryPermissionDenied0001', 0, async function (done) { 2804 console.log(TAG + "************* testQueryPermissionDenied0001 start *************"); 2805 try { 2806 var predicate = new dataSharePredicates.DataSharePredicates(); 2807 await rdbStore.query("test", predicate); 2808 expect(null).assertFail(); 2809 } catch (err) { 2810 console.log("catch err: failed, err: code=" + err.code + " message=" + err.message) 2811 expect("202").assertEqual(err.code) 2812 done() 2813 } 2814 console.log(TAG + "************* testQueryPermissionDenied0001 end *************"); 2815 }) 2816 2817 /** 2818 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0261 2819 * @tc.name Normal test case of predicates, test "notLike" for string value 2820 * @tc.desc 1.Execute notLike ("stringValue", "ABCDEFGHIJKLMN") 2821 * 2.Query data 2822 */ 2823 it('testNotLike0001', 0, async function (done) { 2824 console.log(TAG + "************* testNotLike0001 start *************"); 2825 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2826 predicates.notLike("stringValue", "ABCDEFGHIJKLMN"); 2827 let result = await rdbStore.query(predicates); 2828 expect(0).assertEqual(result.rowCount); 2829 result.close() 2830 result = null 2831 done(); 2832 console.log(TAG + "************* testNotLike0001 end *************"); 2833 }) 2834 2835 /** 2836 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0262 2837 * @tc.name Normal test case of predicates, test "notLike" for string value 2838 * @tc.desc 1.Execute notLike ("stringValue", "LMNX") 2839 * 2.Query data 2840 */ 2841 it('testNotLike0002', 0, async function (done) { 2842 console.log(TAG + "************* testNotLike0002 start *************"); 2843 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2844 predicates.notLike("stringValue", "LMNX"); 2845 let result = await rdbStore.query(predicates); 2846 expect(3).assertEqual(result.rowCount); 2847 result.close() 2848 result = null 2849 done(); 2850 console.log(TAG + "************* testNotLike0002 end *************"); 2851 }) 2852 2853 /** 2854 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0263 2855 * @tc.name Normal test case of predicates, test "notLike" for Chinese character value 2856 * @tc.desc 1.Execute notLike ("characterValue", "%中%") 2857 * 2.Query data 2858 */ 2859 it('testNotLike0003', 0, async function (done) { 2860 console.log(TAG + "************* testNotLike0003 start *************"); 2861 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2862 predicates.notLike("characterValue", "%中%"); 2863 let result = await rdbStore.query(predicates); 2864 expect(2).assertEqual(result.rowCount); 2865 result.close() 2866 result = null 2867 done(); 2868 console.log(TAG + "************* testNotLike0003 end *************"); 2869 }) 2870 2871 /** 2872 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0264 2873 * @tc.name Normal test case of predicates, test "notLike" for character value 2874 * @tc.desc 1.Execute notLike ("characterValue", "#") 2875 * 2.Query data 2876 */ 2877 it('testNotLike0004', 0, async function (done) { 2878 console.log(TAG + "************* testNotLike0004 start *************"); 2879 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2880 predicates.notLike("characterValue", "#"); 2881 let result = await rdbStore.query(predicates); 2882 expect(2).assertEqual(result.rowCount); 2883 result.close() 2884 result = null 2885 done(); 2886 console.log(TAG + "************* testNotLike0004 end *************"); 2887 }) 2888 2889 /** 2890 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0265 2891 * @tc.name Abnormal test case of predicates, test "notLike" for character value 2892 * @tc.desc 1.Execute notLike ("characterValue", null) 2893 * 2.Query data 2894 * 3.Execute notLike ("characterValue", undefined) 2895 * 4.Query data 2896 */ 2897 it('testNotLike0005', 0, async function (done) { 2898 console.info(TAG, `************* testNotLike0005 start *************`); 2899 try { 2900 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2901 predicates.notLike("characterValue", null); 2902 expect(null).assertFail(); 2903 done(); 2904 } catch (err) { 2905 console.error(TAG, `predicates.notLike failed: err code=${err.code}, message=${err.message}`); 2906 expect("401").assertEqual(err.code); 2907 } 2908 2909 try { 2910 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2911 predicates.notLike("characterValue", undefined); 2912 expect(null).assertEqual(); 2913 done(); 2914 } catch (err) { 2915 console.error(TAG, `predicates.notLike failed: err code=${err.code}, message=${err.message}`); 2916 expect("401").assertEqual(err.code); 2917 done(); 2918 } 2919 console.info(TAG, `************* testNotLike0005 end *************`); 2920 }) 2921 2922 /** 2923 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0266 2924 * @tc.name Normal test case of predicates, test "notLike" for character value 2925 * @tc.desc 1.Execute notLike ("characterValue", "#") 2926 * 2.Query data 2927 * 3.close result 2928 * 4.insert data 2929 * 5.Execute notLike ("characterValue", "#") 2930 * 6.Query data 2931 */ 2932 it('testNotLike0006', 0, async function (done) { 2933 console.log(TAG + "************* testNotLike0006 start *************"); 2934 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2935 predicates.notLike("characterValue", "#"); 2936 let result = await rdbStore.query(predicates); 2937 expect(2).assertEqual(result.rowCount); 2938 result.close() 2939 result = null 2940 await rdbStore.insert("AllDataType", valueBucket4) 2941 let predicatesInsert = new data_relationalStore.RdbPredicates("AllDataType"); 2942 predicatesInsert.notLike("characterValue", "#"); 2943 result = await rdbStore.query(predicatesInsert); 2944 expect(2).assertEqual(result.rowCount); 2945 result.close(); 2946 result = null; 2947 let predicatesBefore = new data_relationalStore.RdbPredicates("AllDataType"); 2948 predicatesBefore.equalTo("stringValue", "OPQRST"); 2949 await rdbStore.delete(predicatesBefore); 2950 done(); 2951 console.log(TAG + "************* testNotLike0006 end *************"); 2952 }) 2953 2954 /** 2955 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0267 2956 * @tc.name Normal test case of predicates, test "notLike" for character value 2957 * @tc.desc 1.Execute notLike ("characterValue", "#") 2958 * 2.Query data 2959 * 3.close result 2960 * 4.updata data 2961 * 5.Execute notLike ("characterValue", "#") 2962 * 6.Query data 2963 */ 2964 it('testNotLike0007', 0, async function (done) { 2965 console.log(TAG + "************* testNotLike0007 start *************"); 2966 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 2967 predicates.notLike("characterValue", "#"); 2968 let result = await rdbStore.query(predicates); 2969 expect(2).assertEqual(result.rowCount); 2970 result.close() 2971 result = null 2972 predicates.equalTo("characterValue", "中"); 2973 await rdbStore.update(valueBucket4, predicates); 2974 let predicatesUpdate = new data_relationalStore.RdbPredicates("AllDataType"); 2975 predicatesUpdate.notLike("characterValue", "#"); 2976 result = await rdbStore.query(predicatesUpdate); 2977 expect(1).assertEqual(result.rowCount); 2978 result.close(); 2979 result = null; 2980 let predicatesBefore = new data_relationalStore.RdbPredicates("AllDataType"); 2981 predicatesBefore.equalTo("stringValue", "OPQRST"); 2982 await rdbStore.update(valueBucket2, predicatesBefore); 2983 done(); 2984 console.log(TAG + "************* testNotLike0007 end *************"); 2985 }) 2986 2987 /** 2988 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0268 2989 * @tc.name Normal test case of predicates, test "notLike" for character value 2990 * @tc.desc 1.Execute notLike ("characterValue", "#") 2991 * 2.Query data 2992 * 3.close result 2993 * 4.delete data 2994 * 5.Execute notLike ("characterValue", "#") 2995 * 6.Query data 2996 */ 2997 it('testNotLike0008', 0, async function (done) { 2998 console.log(TAG + "************* testNotLike0008 start *************"); 2999 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3000 predicates.notLike("characterValue", "#"); 3001 let result = await rdbStore.query(predicates); 3002 expect(2).assertEqual(result.rowCount); 3003 result.close(); 3004 result = null; 3005 predicates.equalTo("characterValue", "中"); 3006 await rdbStore.delete(predicates); 3007 let predicatesDelete = new data_relationalStore.RdbPredicates("AllDataType"); 3008 predicatesDelete.notLike("characterValue", "#"); 3009 result = await rdbStore.query(predicatesDelete); 3010 expect(1).assertEqual(result.rowCount); 3011 result.close(); 3012 result = null; 3013 await rdbStore.insert("AllDataType", valueBucket2); 3014 done(); 3015 console.log(TAG + "************* testNotLike0008 end *************"); 3016 }) 3017 3018 /** 3019 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0269 3020 * @tc.name Normal test case of predicates, test "notContains" for string value 3021 * @tc.desc 1.Execute notContains ("stringValue", "ABC") 3022 * 2.Query data 3023 */ 3024 it('testNotContains0001', 0, async function (done) { 3025 console.log(TAG + "************* testNotContains0001 start *************"); 3026 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3027 predicates.notContains("stringValue", "ABC"); 3028 let result = await rdbStore.query(predicates); 3029 expect(0).assertEqual(result.rowCount); 3030 result.close() 3031 result = null 3032 done(); 3033 console.log(TAG + "************* testNotContains0001 end *************"); 3034 }) 3035 3036 /** 3037 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0270 3038 * @tc.name Normal test case of predicates, test "notContains" for string value 3039 * @tc.desc 1.Execute notContains ("stringValue", "ABCX") 3040 * 2.Query data 3041 */ 3042 it('testNotContains0002', 0, async function (done) { 3043 console.log(TAG + "************* testNotContains0002 start *************"); 3044 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3045 predicates.notContains("stringValue", "ABCX"); 3046 let result = await rdbStore.query(predicates); 3047 expect(3).assertEqual(result.rowCount); 3048 result.close() 3049 result = null 3050 done(); 3051 console.log(TAG + "************* testNotContains0002 end *************"); 3052 }) 3053 3054 /** 3055 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0271 3056 * @tc.name Normal test case of predicates, test "notContains" for Chinese character value 3057 * @tc.desc 1.Execute notContains ("characterValue", "中") 3058 * 2.Query data 3059 */ 3060 it('testNotContains0003', 0, async function (done) { 3061 console.log(TAG + "************* testNotContains0003 start *************"); 3062 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3063 predicates.notContains("characterValue", "中"); 3064 let result = await rdbStore.query(predicates); 3065 expect(2).assertEqual(result.rowCount); 3066 result.close() 3067 result = null 3068 done(); 3069 console.log(TAG + "************* testNotContains0003 end *************"); 3070 }) 3071 3072 /** 3073 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0272 3074 * @tc.name Normal test case of predicates, test "notContains" for character value 3075 * @tc.desc 1.Execute notContains ("characterValue", "#") 3076 * 2.Query data 3077 */ 3078 it('testNotContains0004', 0, async function (done) { 3079 console.log(TAG + "************* testNotContains0004 start *************"); 3080 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3081 predicates.notContains("characterValue", "#"); 3082 let result = await rdbStore.query(predicates); 3083 expect(2).assertEqual(result.rowCount); 3084 result.close() 3085 result = null 3086 done(); 3087 console.log(TAG + "************* testNotContains0004 end *************"); 3088 }) 3089 3090 /** 3091 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0273 3092 * @tc.name Abnormal test case of predicates, test "notContains" for character value 3093 * @tc.desc 1.Execute notContains ("characterValue", null) 3094 * 2.Query data 3095 * 3.Execute notContains ("characterValue", undefined) 3096 * 4.Query data 3097 */ 3098 it('testNotContains0005', 0, async function (done) { 3099 console.info(TAG, `************* testNotContains0005 start *************`); 3100 try { 3101 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3102 predicates.notContains("characterValue", null); 3103 expect(null).assertFail(); 3104 done(); 3105 } catch (err) { 3106 console.error(TAG, `predicates.notContains failed: err code=${err.code}, message=${err.message}`); 3107 expect("401").assertEqual(err.code); 3108 } 3109 3110 try { 3111 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3112 predicates.notContains("characterValue", undefined); 3113 expect(null).assertFail(); 3114 done(); 3115 } catch (err) { 3116 console.error(TAG, `predicates.notContains failed: err code=${err.code}, message=${err.message}`); 3117 expect("401").assertEqual(err.code); 3118 done(); 3119 } 3120 console.info(TAG, `************* testNotContains0005 end *************`); 3121 }) 3122 3123 /** 3124 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0274 3125 * @tc.name Normal test case of predicates, test "notContains" for character value 3126 * @tc.desc 1.Execute notContains ("characterValue", "#") 3127 * 2.Query data 3128 * 3.close result 3129 * 4.insert data 3130 * 5.Execute notContains ("characterValue", "#") 3131 * 6.Query data 3132 */ 3133 it('testNotContains0006', 0, async function (done) { 3134 console.log(TAG + "************* testNotContains0006 start *************"); 3135 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3136 predicates.notContains("characterValue", "#"); 3137 let result = await rdbStore.query(predicates); 3138 expect(2).assertEqual(result.rowCount); 3139 result.close() 3140 result = null 3141 await rdbStore.insert("AllDataType", valueBucket4) 3142 let predicatesInsert = new data_relationalStore.RdbPredicates("AllDataType"); 3143 predicatesInsert.notContains("characterValue", "#"); 3144 result = await rdbStore.query(predicatesInsert); 3145 expect(2).assertEqual(result.rowCount); 3146 result.close(); 3147 result = null; 3148 let predicatesBefore = new data_relationalStore.RdbPredicates("AllDataType"); 3149 predicatesBefore.equalTo("stringValue", "OPQRST"); 3150 await rdbStore.delete(predicatesBefore); 3151 done(); 3152 console.log(TAG + "************* testNotContains0006 end *************"); 3153 }) 3154 3155 /** 3156 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0275 3157 * @tc.name Normal test case of predicates, test "notContains" for character value 3158 * @tc.desc 1.Execute notContains ("characterValue", "#") 3159 * 2.Query data 3160 * 3.close result 3161 * 4.updata data 3162 * 5.Execute notContains ("characterValue", "#") 3163 * 6.Query data 3164 */ 3165 it('testNotContains0007', 0, async function (done) { 3166 console.log(TAG + "************* testNotContains0007 start *************"); 3167 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3168 predicates.notContains("characterValue", "#"); 3169 let result = await rdbStore.query(predicates); 3170 expect(2).assertEqual(result.rowCount); 3171 result.close(); 3172 result = null; 3173 predicates.equalTo("characterValue", "中") 3174 await rdbStore.update(valueBucket4, predicates) 3175 let predicatesUpdate = new data_relationalStore.RdbPredicates("AllDataType"); 3176 predicatesUpdate.notContains("characterValue", "#"); 3177 result = await rdbStore.query(predicatesUpdate); 3178 expect(1).assertEqual(result.rowCount); 3179 result.close(); 3180 result = null; 3181 let predicatesBefore = new data_relationalStore.RdbPredicates("AllDataType"); 3182 predicatesBefore.equalTo("stringValue", "OPQRST"); 3183 await rdbStore.update(valueBucket2, predicatesBefore); 3184 done(); 3185 console.log(TAG + "************* testNotContains0007 end *************"); 3186 }) 3187 3188 /** 3189 * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0276 3190 * @tc.name Normal test case of predicates, test "notContains" for character value 3191 * @tc.desc 1.Execute notContains ("characterValue", "#") 3192 * 2.Query data 3193 * 3.close result 3194 * 4.delete data 3195 * 5.Execute notContains ("characterValue", "#") 3196 * 6.Query data 3197 */ 3198 it('testNotContains0008', 0, async function (done) { 3199 console.log(TAG + "************* testNotContains0008 start *************"); 3200 let predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3201 predicates.notContains("characterValue", "#"); 3202 let result = await rdbStore.query(predicates); 3203 expect(2).assertEqual(result.rowCount); 3204 result.close() 3205 result = null 3206 predicates.equalTo("characterValue", "中") 3207 await rdbStore.delete(predicates) 3208 predicates = new data_relationalStore.RdbPredicates("AllDataType"); 3209 predicates.notContains("characterValue", "#"); 3210 result = await rdbStore.query(predicates); 3211 expect(1).assertEqual(result.rowCount); 3212 result.close(); 3213 result = null; 3214 await rdbStore.insert("AllDataType", valueBucket2); 3215 done(); 3216 console.log(TAG + "************* testNotContains0008 end *************"); 3217 }) 3218 3219 console.log(TAG + "*************Unit Test End*************"); 3220})