1 /*
2 * Copyright (c) 2023 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 */
15
16 #include <gtest/gtest.h>
17 #include <sys/stat.h>
18 #include <sys/types.h>
19
20 #include <string>
21
22 #include "common.h"
23 #include "oh_data_define.h"
24 #include "oh_value_object.h"
25 #include "relational_store.h"
26 #include "relational_store_error_code.h"
27 using namespace testing::ext;
28 using namespace OHOS::NativeRdb;
29
30 class RdbNativePredicatesTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
InitRdbConfig()36 static void InitRdbConfig()
37 {
38 config_.dataBaseDir = RDB_TEST_PATH;
39 config_.storeName = "rdb_predicates_test.db";
40 config_.bundleName = "com.ohos.example.distributedndk";
41 config_.moduleName = "";
42 config_.securityLevel = OH_Rdb_SecurityLevel::S1;
43 config_.isEncrypt = false;
44 config_.selfSize = sizeof(OH_Rdb_Config);
45 }
46 static OH_Rdb_Config config_;
47 };
48
49 OH_Rdb_Store *predicatesTestRdbStore_;
50 OH_Rdb_Config RdbNativePredicatesTest::config_ = { 0 };
51 const char HAVING_CREATE_SQL[] =
52 "CREATE TABLE IF NOT EXISTS orders (id INTEGER PRIMARY KEY AUTOINCREMENT, customer_id INTEGER, amount INTEGER)";
53 const char HAVING_INSERT_SQL[] =
54 "INSERT INTO orders (customer_id, amount) VALUES (1, 1500), (1, 2000), (1, 3000), (2, 800), (2, 1200), (3, 1500),"
55 " (3, 2000), (3, 2500), (3, 1000)";
56 const char HAVING_DROP_SQL[] = "DROP TABLE IF EXISTS orders";
SetUpTestCase(void)57 void RdbNativePredicatesTest::SetUpTestCase(void)
58 {
59 InitRdbConfig();
60 mkdir(config_.dataBaseDir, 0770);
61 int errCode = 0;
62 char table[] = "test";
63 predicatesTestRdbStore_ = OH_Rdb_GetOrOpen(&config_, &errCode);
64 EXPECT_NE(predicatesTestRdbStore_, NULL);
65
66 char createTableSql[] = "CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
67 "data3 FLOAT, data4 BLOB, data5 TEXT);";
68 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, createTableSql);
69
70 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
71 valueBucket->putInt64(valueBucket, "id", 1);
72 valueBucket->putText(valueBucket, "data1", "zhangSan");
73 valueBucket->putInt64(valueBucket, "data2", 12800);
74 valueBucket->putReal(valueBucket, "data3", 100.1);
75 uint8_t arr[] = { 1, 2, 3, 4, 5 };
76 int len = sizeof(arr) / sizeof(arr[0]);
77 valueBucket->putBlob(valueBucket, "data4", arr, len);
78 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
79 errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
80 EXPECT_EQ(errCode, 1);
81
82 valueBucket->clear(valueBucket);
83 valueBucket->putInt64(valueBucket, "id", 2);
84 valueBucket->putText(valueBucket, "data1", "liSi");
85 valueBucket->putInt64(valueBucket, "data2", 13800);
86 valueBucket->putReal(valueBucket, "data3", 200.1);
87 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
88 errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
89 EXPECT_EQ(errCode, 2);
90
91 valueBucket->clear(valueBucket);
92 valueBucket->putInt64(valueBucket, "id", 3);
93 valueBucket->putText(valueBucket, "data1", "wangWu");
94 valueBucket->putInt64(valueBucket, "data2", 14800);
95 valueBucket->putReal(valueBucket, "data3", 300.1);
96 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
97 errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
98 EXPECT_EQ(errCode, 3);
99
100 valueBucket->destroy(valueBucket);
101 }
102
TearDownTestCase(void)103 void RdbNativePredicatesTest::TearDownTestCase(void)
104 {
105 char dropTableSql[] = "DROP TABLE IF EXISTS test";
106 int errCode = OH_Rdb_Execute(predicatesTestRdbStore_, dropTableSql);
107 EXPECT_EQ(errCode, 0);
108 delete predicatesTestRdbStore_;
109 predicatesTestRdbStore_ = NULL;
110 OH_Rdb_DeleteStore(&config_);
111 }
112
SetUp(void)113 void RdbNativePredicatesTest::SetUp(void)
114 {
115 }
116
TearDown(void)117 void RdbNativePredicatesTest::TearDown(void)
118 {
119 }
120
121 /**
122 * @tc.name: RDB_Native_predicates_test_001
123 * @tc.desc: Normal testCase of Predicates for EqualTo、AndOR、beginWrap and endWrap
124 * @tc.type: FUNC
125 */
126 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_001, TestSize.Level1)
127 {
128 int errCode = 0;
129 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
130 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
131 uint32_t count = 1;
132 const char *data1Value = "zhangSan";
133 valueObject->putText(valueObject, data1Value);
134 predicates->beginWrap(predicates)->equalTo(predicates, "data1", valueObject)->orOperate(predicates);
135 double data3Value = 200.1;
136 valueObject->putDouble(valueObject, &data3Value, count);
137 predicates->equalTo(predicates, "data3", valueObject)->endWrap(predicates);
138
139 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
140 EXPECT_NE(cursor, NULL);
141 int rowCount = 0;
142 errCode = cursor->getRowCount(cursor, &rowCount);
143 EXPECT_EQ(rowCount, 2);
144
145 valueObject->destroy(valueObject);
146 predicates->destroy(predicates);
147 cursor->destroy(cursor);
148 }
149
150 /**
151 * @tc.name: RDB_Native_predicates_test_002
152 * @tc.desc: Normal testCase of Predicates for NotEqualTo
153 * @tc.type: FUNC
154 */
155 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_002, TestSize.Level1)
156 {
157 int errCode = 0;
158 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
159 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
160 const char *data1Value = "zhangSan";
161 valueObject->putText(valueObject, data1Value);
162 predicates->notEqualTo(predicates, "data1", valueObject);
163
164 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
165 EXPECT_NE(cursor, NULL);
166 int rowCount = 0;
167 errCode = cursor->getRowCount(cursor, &rowCount);
168 EXPECT_EQ(errCode, 0);
169 EXPECT_EQ(rowCount, 2);
170
171 valueObject->destroy(valueObject);
172 predicates->destroy(predicates);
173 cursor->destroy(cursor);
174 }
175
176 /**
177 * @tc.name: RDB_Native_predicates_test_003
178 * @tc.desc: Normal testCase of Predicates for GreaterThan
179 * @tc.type: FUNC
180 */
181 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_003, TestSize.Level1)
182 {
183 int errCode = 0;
184 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
185 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
186 const char *data5Value = "ABCDEFG";
187 valueObject->putText(valueObject, data5Value);
188 predicates->greaterThan(predicates, "data5", valueObject);
189
190 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
191 EXPECT_NE(cursor, NULL);
192 int rowCount = 0;
193 errCode = cursor->getRowCount(cursor, &rowCount);
194 EXPECT_EQ(rowCount, 2);
195
196 cursor->goToNextRow(cursor);
197 int columnCount = 0;
198 cursor->getColumnCount(cursor, &columnCount);
199 EXPECT_EQ(columnCount, 6);
200
201 int64_t id;
202 cursor->getInt64(cursor, 0, &id);
203 EXPECT_EQ(id, 2);
204
205 size_t size = 0;
206 cursor->getSize(cursor, 1, &size);
207 char data1Value[size];
208 cursor->getText(cursor, 1, data1Value, size);
209 EXPECT_EQ(strcmp(data1Value, "liSi"), 0);
210
211 int64_t data2Value;
212 cursor->getInt64(cursor, 2, &data2Value);
213 EXPECT_EQ(data2Value, 13800);
214
215 double data3Value;
216 cursor->getReal(cursor, 3, &data3Value);
217 EXPECT_EQ(data3Value, 200.1);
218
219 bool isNull = false;
220 cursor->isNull(cursor, 4, &isNull);
221 EXPECT_EQ(isNull, true);
222
223 cursor->getSize(cursor, 5, &size);
224 char data5Value1[size];
225 cursor->getText(cursor, 5, data5Value1, size);
226 EXPECT_EQ(strcmp(data5Value1, "ABCDEFGH"), 0);
227
228 cursor->goToNextRow(cursor);
229 cursor->getInt64(cursor, 0, &id);
230 EXPECT_EQ(id, 3);
231
232 valueObject->destroy(valueObject);
233 predicates->destroy(predicates);
234 cursor->destroy(cursor);
235 }
236
237 /**
238 * @tc.name: RDB_Native_predicates_test_004
239 * @tc.desc: Normal testCase of Predicates for GreaterThanOrEqualTo
240 * @tc.type: FUNC
241 */
242 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_004, TestSize.Level1)
243 {
244 int errCode = 0;
245 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
246 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
247 const char *data5Value = "ABCDEFG";
248 valueObject->putText(valueObject, data5Value);
249 predicates->greaterThanOrEqualTo(predicates, "data5", valueObject);
250
251 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
252 EXPECT_NE(cursor, NULL);
253 int rowCount = 0;
254 errCode = cursor->getRowCount(cursor, &rowCount);
255 EXPECT_EQ(rowCount, 3);
256
257 valueObject->destroy(valueObject);
258 predicates->destroy(predicates);
259 cursor->destroy(cursor);
260 }
261
262 /**
263 * @tc.name: RDB_Native_predicates_test_005
264 * @tc.desc: Normal testCase of Predicates for LessThan
265 * @tc.type: FUNC
266 */
267 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_005, TestSize.Level1)
268 {
269 int errCode = 0;
270 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
271 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
272 const char *data5Value = "ABCDEFG";
273 valueObject->putText(valueObject, data5Value);
274 predicates->lessThan(predicates, "data5", valueObject);
275
276 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
277 EXPECT_NE(cursor, NULL);
278 int rowCount = 0;
279 errCode = cursor->getRowCount(cursor, &rowCount);
280 EXPECT_EQ(rowCount, 0);
281
282 valueObject->destroy(valueObject);
283 predicates->destroy(predicates);
284 cursor->destroy(cursor);
285 }
286
287 /**
288 * @tc.name: RDB_Native_predicates_test_006
289 * @tc.desc: Normal testCase of Predicates for LessThanOrEqualTo
290 * @tc.type: FUNC
291 */
292 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_006, TestSize.Level1)
293 {
294 int errCode = 0;
295 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
296 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
297 const char *data5Value = "ABCDEFG";
298 valueObject->putText(valueObject, data5Value);
299 predicates->lessThanOrEqualTo(predicates, "data5", valueObject);
300
301 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
302 EXPECT_NE(cursor, NULL);
303 int rowCount = 0;
304 errCode = cursor->getRowCount(cursor, &rowCount);
305 EXPECT_EQ(rowCount, 1);
306
307 valueObject->destroy(valueObject);
308 predicates->destroy(predicates);
309 cursor->destroy(cursor);
310 }
311
312 /**
313 * @tc.name: RDB_Native_predicates_test_007
314 * @tc.desc: Normal testCase of Predicates for IsNull.
315 * @tc.type: FUNC
316 */
317 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_007, TestSize.Level1)
318 {
319 int errCode = 0;
320 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
321 predicates->isNull(predicates, "data4");
322
323 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
324 EXPECT_NE(cursor, NULL);
325 int rowCount = 0;
326 errCode = cursor->getRowCount(cursor, &rowCount);
327 EXPECT_EQ(rowCount, 2);
328
329 predicates->destroy(predicates);
330 cursor->destroy(cursor);
331 }
332
333 /**
334 * @tc.name: RDB_Native_predicates_test_008
335 * @tc.desc: Normal testCase of Predicates for IsNull.
336 * @tc.type: FUNC
337 */
338 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_008, TestSize.Level1)
339 {
340 int errCode = 0;
341 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
342 predicates->isNotNull(predicates, "data4");
343
344 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
345 EXPECT_NE(cursor, NULL);
346 int rowCount = 0;
347 errCode = cursor->getRowCount(cursor, &rowCount);
348 EXPECT_EQ(rowCount, 1);
349
350 predicates->destroy(predicates);
351 cursor->destroy(cursor);
352 }
353
354 /**
355 * @tc.name: RDB_Native_predicates_test_009
356 * @tc.desc: Normal testCase of Predicates for Between
357 * @tc.type: FUNC
358 */
359 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_009, TestSize.Level1)
360 {
361 int errCode = 0;
362 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
363 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
364 int64_t data2Value[] = { 12000, 13000 };
365 uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
366 valueObject->putInt64(valueObject, data2Value, len);
367 predicates->between(predicates, "data2", valueObject);
368 double data3Value[] = { 0.1, 101.1 };
369 len = sizeof(data3Value) / sizeof(data3Value[0]);
370 valueObject->putDouble(valueObject, data3Value, len);
371 predicates->between(predicates, "data3", valueObject);
372
373 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
374 EXPECT_NE(cursor, NULL);
375 int rowCount = 0;
376 errCode = cursor->getRowCount(cursor, &rowCount);
377 EXPECT_EQ(rowCount, 1);
378
379 valueObject->destroy(valueObject);
380 predicates->destroy(predicates);
381 cursor->destroy(cursor);
382 }
383
384 /**
385 * @tc.name: RDB_Native_predicates_test_010
386 * @tc.desc: Normal testCase of Predicates for NotBetween
387 * @tc.type: FUNC
388 */
389 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_010, TestSize.Level1)
390 {
391 int errCode = 0;
392 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
393 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
394 int64_t data2Value[] = { 12000, 13000 };
395 int len = sizeof(data2Value) / sizeof(data2Value[0]);
396 valueObject->putInt64(valueObject, data2Value, len);
397 predicates->notBetween(predicates, "data2", valueObject);
398
399 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
400 EXPECT_NE(cursor, NULL);
401 int rowCount = 0;
402 errCode = cursor->getRowCount(cursor, &rowCount);
403 EXPECT_EQ(rowCount, 2);
404
405 valueObject->destroy(valueObject);
406 predicates->destroy(predicates);
407 cursor->destroy(cursor);
408 }
409
410 /**
411 * @tc.name: RDB_Native_predicates_test_011
412 * @tc.desc: Normal testCase of Predicates for OrderBy、Limit、Offset.
413 * @tc.type: FUNC
414 */
415 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_011, TestSize.Level1)
416 {
417 int errCode = 0;
418 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
419 predicates->orderBy(predicates, "data2", OH_OrderType::ASC);
420 predicates->limit(predicates, 1);
421 predicates->offset(predicates, 1);
422 predicates->distinct(predicates);
423
424 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
425 EXPECT_NE(cursor, NULL);
426 int rowCount = 0;
427 errCode = cursor->getRowCount(cursor, &rowCount);
428 EXPECT_EQ(rowCount, 1);
429
430 errCode = cursor->goToNextRow(cursor);
431 int columnIndex;
432 cursor->getColumnIndex(cursor, "data2", &columnIndex);
433 EXPECT_EQ(columnIndex, 2);
434 int64_t longValue;
435 cursor->getInt64(cursor, columnIndex, &longValue);
436 EXPECT_EQ(longValue, 13800);
437
438 predicates->destroy(predicates);
439 cursor->destroy(cursor);
440 }
441
442 /**
443 * @tc.name: RDB_Native_predicates_test_012
444 * @tc.desc: Normal testCase of Predicates for In.
445 * @tc.type: FUNC
446 */
447 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_012, TestSize.Level1)
448 {
449 int errCode = 0;
450 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
451 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
452 const char *data1Value[] = { "zhangSan", "liSi" };
453 int len = sizeof(data1Value) / sizeof(data1Value[0]);
454 valueObject->putTexts(valueObject, data1Value, len);
455 predicates->in(predicates, "data1", valueObject);
456
457 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
458 EXPECT_NE(cursor, NULL);
459 int rowCount = 0;
460 errCode = cursor->getRowCount(cursor, &rowCount);
461 EXPECT_EQ(rowCount, 2);
462
463 valueObject->destroy(valueObject);
464 predicates->destroy(predicates);
465 cursor->destroy(cursor);
466 }
467
468 /**
469 * @tc.name: RDB_Native_predicates_test_013
470 * @tc.desc: Normal testCase of Predicates for NotIn.
471 * @tc.type: FUNC
472 */
473 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_013, TestSize.Level1)
474 {
475 int errCode = 0;
476 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
477 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
478 const char *data1Value[] = { "zhangSan", "liSi" };
479 int len = sizeof(data1Value) / sizeof(data1Value[0]);
480 valueObject->putTexts(valueObject, data1Value, len);
481 predicates->notIn(predicates, "data1", valueObject);
482
483 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
484 EXPECT_NE(cursor, NULL);
485 int rowCount = 0;
486 errCode = cursor->getRowCount(cursor, &rowCount);
487 EXPECT_EQ(rowCount, 1);
488
489 valueObject->destroy(valueObject);
490 predicates->destroy(predicates);
491 cursor->destroy(cursor);
492 }
493
494 /**
495 * @tc.name: RDB_Native_predicates_test_014
496 * @tc.desc: Normal testCase of Predicates for Like.
497 * @tc.type: FUNC
498 */
499 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_014, TestSize.Level1)
500 {
501 int errCode = 0;
502 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
503 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
504 const char *data5Value = "ABCD%";
505 valueObject->putText(valueObject, data5Value);
506 predicates->like(predicates, "data5", valueObject);
507 const char *data2Value = "%800";
508 valueObject->putText(valueObject, data2Value);
509 predicates->like(predicates, "data2", valueObject);
510
511 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
512 EXPECT_NE(cursor, NULL);
513 int rowCount = 0;
514 errCode = cursor->getRowCount(cursor, &rowCount);
515 EXPECT_EQ(rowCount, 3);
516
517 valueObject->destroy(valueObject);
518 predicates->destroy(predicates);
519 cursor->destroy(cursor);
520 }
521
522 /**
523 * @tc.name: RDB_Native_predicates_test_015
524 * @tc.desc: Normal testCase of Predicates for GroupBy.
525 * @tc.type: FUNC
526 */
527 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_015, TestSize.Level1)
528 {
529 int errCode = 0;
530 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
531 const char *columnNames[] = { "data1", "data2" };
532 int len = sizeof(columnNames) / sizeof(columnNames[0]);
533 predicates->groupBy(predicates, columnNames, len);
534
535 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
536 EXPECT_NE(cursor, NULL);
537 int rowCount = 0;
538 errCode = cursor->getRowCount(cursor, &rowCount);
539 EXPECT_EQ(rowCount, 3);
540
541 predicates->destroy(predicates);
542 cursor->destroy(cursor);
543 }
544
545 /**
546 * @tc.name: RDB_Native_predicates_test_016
547 * @tc.desc: Normal testCase of Predicates for And.
548 * @tc.type: FUNC
549 */
550 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_016, TestSize.Level1)
551 {
552 int errCode = 0;
553 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
554 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
555 const char *data1Value = "zhangSan";
556 valueObject->putText(valueObject, data1Value);
557 predicates->equalTo(predicates, "data1", valueObject);
558 predicates->andOperate(predicates);
559 double data3Value = 100.1;
560 valueObject->putDouble(valueObject, &data3Value, 1);
561 predicates->equalTo(predicates, "data3", valueObject);
562
563 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
564 EXPECT_NE(cursor, NULL);
565 int rowCount = 0;
566 errCode = cursor->getRowCount(cursor, &rowCount);
567 EXPECT_EQ(rowCount, 1);
568
569 valueObject->destroy(valueObject);
570 predicates->destroy(predicates);
571 errCode = cursor->destroy(cursor);
572 }
573
574 /**
575 * @tc.name: RDB_Native_predicates_test_017
576 * @tc.desc: Normal testCase of Predicates for Clear.
577 * @tc.type: FUNC
578 */
579 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_017, TestSize.Level1)
580 {
581 int errCode = 0;
582 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
583 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
584 const char *data1Value = "zhangSan";
585 valueObject->putText(valueObject, data1Value);
586 predicates->equalTo(predicates, "data1", valueObject);
587
588 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
589 EXPECT_NE(cursor, NULL);
590 int rowCount = 0;
591 errCode = cursor->getRowCount(cursor, &rowCount);
592 EXPECT_EQ(rowCount, 1);
593 errCode = cursor->destroy(cursor);
594
595 predicates->clear(predicates);
596 predicates->notEqualTo(predicates, "data1", valueObject);
597 cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
598 EXPECT_NE(cursor, NULL);
599 errCode = cursor->getRowCount(cursor, &rowCount);
600 EXPECT_EQ(rowCount, 2);
601
602 valueObject->destroy(valueObject);
603 predicates->destroy(predicates);
604 cursor->destroy(cursor);
605 }
606 /**
607 * @tc.name: RDB_Native_predicates_test_018
608 * @tc.desc: Normal testCase of Predicates for table name is NULL.
609 * @tc.type: FUNC
610 */
611 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_018, TestSize.Level1)
612 {
613 char *table = NULL;
614 OH_Predicates *predicates = OH_Rdb_CreatePredicates(table);
615 EXPECT_EQ(predicates, NULL);
616
617 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
618 EXPECT_EQ(cursor, NULL);
619 }
620
621 /**
622 * @tc.name: RDB_Native_predicates_test_019
623 * @tc.desc: Normal testCase of Predicates for anomalous branch.
624 * @tc.type: FUNC
625 */
626 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_019, TestSize.Level1)
627 {
628 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
629 EXPECT_NE(predicates, NULL);
630
631 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
632 const char *data1Value = "zhangSan";
633 valueObject->putText(valueObject, data1Value);
634 predicates->equalTo(nullptr, "data1", valueObject);
635 predicates->equalTo(predicates, nullptr, valueObject);
636 predicates->equalTo(predicates, "data1", nullptr);
637 predicates->notEqualTo(nullptr, "data1", valueObject);
638 predicates->notEqualTo(predicates, nullptr, valueObject);
639 predicates->notEqualTo(predicates, "data1", nullptr);
640
641 predicates->beginWrap(nullptr);
642 predicates->endWrap(nullptr);
643
644 predicates->orOperate(nullptr);
645 predicates->andOperate(nullptr);
646
647 predicates->isNull(nullptr, "data4");
648 predicates->isNull(predicates, nullptr);
649 predicates->isNotNull(nullptr, "data4");
650 predicates->isNotNull(predicates, nullptr);
651
652 const char *data5ValueLike = "ABCD%";
653 valueObject->putText(valueObject, data5ValueLike);
654 predicates->like(nullptr, "data5", valueObject);
655 predicates->like(predicates, nullptr, valueObject);
656 predicates->like(predicates, "data5", nullptr);
657
658 int64_t data2Value[] = { 12000, 13000 };
659 uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
660 valueObject->putInt64(valueObject, data2Value, len);
661 predicates->between(nullptr, "data2", valueObject);
662 predicates->between(predicates, nullptr, valueObject);
663 predicates->between(predicates, "data2", nullptr);
664 predicates->notBetween(nullptr, "data2", valueObject);
665 predicates->notBetween(predicates, nullptr, valueObject);
666 predicates->notBetween(predicates, "data2", nullptr);
667 int64_t data2Value_1[] = { 12000 };
668 len = sizeof(data2Value_1) / sizeof(data2Value_1[0]);
669 valueObject->putInt64(valueObject, data2Value_1, len);
670 predicates->between(predicates, "data2", valueObject);
671 predicates->notBetween(predicates, "data2", valueObject);
672
673 valueObject->destroy(valueObject);
674 predicates->destroy(predicates);
675 }
676
677 /**
678 * @tc.name: RDB_Native_predicates_test_020
679 * @tc.desc: Normal testCase of Predicates for anomalous branch.
680 * @tc.type: FUNC
681 */
682 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_020, TestSize.Level1)
683 {
684 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
685 EXPECT_NE(predicates, NULL);
686
687 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
688 const char *data1Value = "zhangSan";
689 valueObject->putText(valueObject, data1Value);
690
691 const char *data5Value = "ABCDEFG";
692 valueObject->putText(valueObject, data5Value);
693 predicates->greaterThan(nullptr, "data5", valueObject);
694 predicates->greaterThan(predicates, nullptr, valueObject);
695 predicates->greaterThan(predicates, "data5", nullptr);
696 predicates->lessThan(nullptr, "data5", valueObject);
697 predicates->lessThan(predicates, nullptr, valueObject);
698 predicates->lessThan(predicates, "data5", nullptr);
699 predicates->greaterThanOrEqualTo(nullptr, "data5", valueObject);
700 predicates->greaterThanOrEqualTo(predicates, nullptr, valueObject);
701 predicates->greaterThanOrEqualTo(predicates, "data5", nullptr);
702 predicates->lessThanOrEqualTo(nullptr, "data5", valueObject);
703 predicates->lessThanOrEqualTo(predicates, nullptr, valueObject);
704 predicates->lessThanOrEqualTo(predicates, "data5", nullptr);
705
706 predicates->orderBy(nullptr, "data2", OH_OrderType::ASC);
707 predicates->orderBy(predicates, nullptr, OH_OrderType::ASC);
708
709 predicates->distinct(nullptr);
710 predicates->limit(nullptr, 1);
711 predicates->offset(nullptr, 1);
712
713 const char *columnNames[] = { "data1", "data2" };
714 uint32_t len = sizeof(columnNames) / sizeof(columnNames[0]);
715 predicates->groupBy(nullptr, columnNames, len);
716 predicates->groupBy(predicates, nullptr, len);
717 predicates->groupBy(predicates, columnNames, 0);
718
719 const char *data1ValueIn[] = { "zhangSan", "liSi" };
720 len = sizeof(data1ValueIn) / sizeof(data1ValueIn[0]);
721 valueObject->putTexts(valueObject, data1ValueIn, len);
722 predicates->in(nullptr, "data1", valueObject);
723 predicates->in(predicates, nullptr, valueObject);
724 predicates->in(predicates, "data1", nullptr);
725 predicates->notIn(nullptr, "data1", valueObject);
726 predicates->notIn(predicates, nullptr, valueObject);
727 predicates->notIn(predicates, "data1", nullptr);
728
729 predicates->clear(nullptr);
730 int errCode = predicates->destroy(nullptr);
731 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
732 valueObject->destroy(valueObject);
733 predicates->destroy(predicates);
734 }
735
736 /**
737 * @tc.name: RDB_Native_predicates_test_021
738 * @tc.desc: Normal testCase of RelationalPredicatesObjects for anomalous branch.
739 * @tc.type: FUNC
740 */
741 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_021, TestSize.Level1)
742 {
743 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
744 int64_t data2Value[] = { 12000, 13000 };
745 uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
746 int errCode = valueObject->putInt64(nullptr, data2Value, len);
747 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
748 errCode = valueObject->putInt64(valueObject, nullptr, len);
749 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
750 errCode = valueObject->putInt64(valueObject, data2Value, 0);
751 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
752
753 uint32_t count = 1;
754 double data3Value = 200.1;
755 errCode = valueObject->putDouble(nullptr, &data3Value, count);
756 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
757 errCode = valueObject->putDouble(valueObject, nullptr, count);
758 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
759 errCode = valueObject->putDouble(valueObject, &data3Value, 0);
760 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
761
762 const char *data1Value = "zhangSan";
763 valueObject->putText(nullptr, data1Value);
764 valueObject->putText(valueObject, nullptr);
765
766 const char *data1ValueTexts[] = { "zhangSan", "liSi" };
767 len = sizeof(data1ValueTexts) / sizeof(data1ValueTexts[0]);
768 errCode = valueObject->putTexts(nullptr, data1ValueTexts, len);
769 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
770 errCode = valueObject->putTexts(valueObject, nullptr, len);
771 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
772 errCode = valueObject->putTexts(valueObject, data1ValueTexts, 0);
773 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
774
775 errCode = valueObject->destroy(nullptr);
776 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
777 valueObject->destroy(valueObject);
778 }
779
780 /**
781 * @tc.name: RDB_Native_predicates_test_025
782 * @tc.desc: Normal testCase of Predicates for having check params.
783 * @tc.type: FUNC
784 */
785 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_025, TestSize.Level1)
786 {
787 OH_Data_Values wrongValues;
788 OH_Predicates wrongPredicates;
789 wrongPredicates.id = 1;
790
791 auto ret = OH_Predicates_Having(nullptr, "data5", &wrongValues);
792 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
793
794 ret = OH_Predicates_Having(&wrongPredicates, "data5", &wrongValues);
795 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
796
797 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
798 EXPECT_NE(predicates, nullptr);
799
800 // test missing group by clause.
801 ret = OH_Predicates_Having(predicates, "data5", &wrongValues);
802 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
803
804 const char *columnNames[] = { "data1"};
805 predicates->groupBy(predicates, columnNames, 1);
806
807 ret = OH_Predicates_Having(predicates, nullptr, &wrongValues);
808 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
809
810 ret = OH_Predicates_Having(predicates, "", &wrongValues);
811 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
812
813 ret = OH_Predicates_Having(predicates, "data5", nullptr);
814 EXPECT_EQ(ret, RDB_OK);
815
816 OH_Data_Value value;
817 value.id = 1;
818 wrongValues.values_.push_back(value);
819 ret = OH_Predicates_Having(predicates, "data5", &wrongValues);
820 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
821
822 wrongValues.id = 1;
823 ret = OH_Predicates_Having(predicates, "data5", &wrongValues);
824 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
825 predicates->destroy(predicates);
826 }
827
828 /**
829 * @tc.name: RDB_Native_predicates_test_026
830 * @tc.desc: Verify scenarios without placeholders and without passing values
831 * 1.Execute OH_Predicates_Having(predicates, "total > 5000 AND count >= 3")
832 * 2.Query data
833 * @tc.type: FUNC
834 */
835 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_026, TestSize.Level1)
836 {
837 auto errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_CREATE_SQL);
838 EXPECT_EQ(errCode, RDB_OK);
839 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_INSERT_SQL);
840 EXPECT_EQ(errCode, RDB_OK);
841
842 OH_Predicates *predicates = OH_Rdb_CreatePredicates("orders");
843 EXPECT_NE(predicates, nullptr);
844 const char *columnNames[] = { "customer_id"};
845 predicates->groupBy(predicates, columnNames, 1);
846 errCode = OH_Predicates_Having(predicates, "total > 5000 AND count >= 3", nullptr);
847 EXPECT_EQ(errCode, RDB_OK);
848
849 const char *columnNames1[] = { "customer_id", "COUNT(*) AS count", "SUM(amount) AS total"};
850 // 3 represents the number of columns.
851 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, columnNames1, 3);
852
853 EXPECT_EQ(cursor->goToNextRow(cursor), RDB_OK);
854 int64_t value;
855 EXPECT_EQ(cursor->getInt64(cursor, 0, &value), E_OK);
856 EXPECT_EQ(value, 1);
857 EXPECT_EQ(cursor->getInt64(cursor, 2, &value), E_OK); // 2 represents the total in the third column.
858 EXPECT_EQ(value, 6500); // 6500 means total price.
859
860 EXPECT_EQ(cursor->goToNextRow(cursor), RDB_OK);
861 EXPECT_EQ(cursor->getInt64(cursor, 0, &value), E_OK);
862 EXPECT_EQ(value, 3);
863 EXPECT_EQ(cursor->getInt64(cursor, 2, &value), E_OK); // 2 represents the total in the third column.
864 EXPECT_EQ(value, 7000); // 7000 means total price.
865
866 predicates->destroy(predicates);
867 cursor->destroy(cursor);
868 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_DROP_SQL);
869 EXPECT_EQ(errCode, RDB_OK);
870 }
871
872 /**
873 * @tc.name: RDB_Native_predicates_test_028
874 * @tc.desc: Test conditions for passing in illegal SQL
875 * 1.Execute OH_Predicates_Having(predicates, "SALARY == 1.2")
876 * 2.Query data
877 * @tc.type: FUNC
878 */
879 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_028, TestSize.Level1)
880 {
881 auto errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_CREATE_SQL);
882 EXPECT_EQ(errCode, RDB_OK);
883 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_INSERT_SQL);
884 EXPECT_EQ(errCode, RDB_OK);
885
886 OH_Predicates *predicates = OH_Rdb_CreatePredicates("orders");
887 EXPECT_NE(predicates, nullptr);
888 const char *columnNames[] = { "customer_id"};
889 predicates->groupBy(predicates, columnNames, 1);
890 errCode = OH_Predicates_Having(predicates, "SALARY == 1.2", nullptr);
891 EXPECT_EQ(errCode, RDB_OK);
892
893 const char *columnNames1[] = { "customer_id", "COUNT(*) AS count", "SUM(amount) AS total"};
894 // 3 represents the number of columns.
895 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, columnNames1, 3);
896 int count;
897 EXPECT_EQ(cursor->getRowCount(cursor, &count), RDB_E_ERROR);
898
899 predicates->destroy(predicates);
900 cursor->destroy(cursor);
901 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_DROP_SQL);
902 EXPECT_EQ(errCode, RDB_OK);
903 }
904
905 /**
906 * @tc.name: RDB_Native_predicates_test_029
907 * @tc.desc: Verify scenarios without placeholders and without passing values
908 * 1.Execute OH_Predicates_Having(predicates, total > ? AND count >= ?", {5000})
909 * 2.Query data
910 * @tc.type: FUNC
911 */
912 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_029, TestSize.Level1)
913 {
914 auto errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_CREATE_SQL);
915 EXPECT_EQ(errCode, RDB_OK);
916 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_INSERT_SQL);
917 EXPECT_EQ(errCode, RDB_OK);
918
919 OH_Predicates *predicates = OH_Rdb_CreatePredicates("orders");
920 EXPECT_NE(predicates, nullptr);
921 const char *columnNames[] = { "customer_id"};
922 predicates->groupBy(predicates, columnNames, 1);
923
924 auto values = OH_Values_Create();
925 OH_Values_PutInt(values, 5000);
926
927 errCode = OH_Predicates_Having(predicates, "total > ? AND count >= ?", values);
928 EXPECT_EQ(errCode, RDB_OK);
929
930 const char *columnNames1[] = { "customer_id", "COUNT(*) AS count", "SUM(amount) AS total"};
931 // 3 represents the number of columns.
932 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, columnNames1, 3);
933 int count = -1;
934 EXPECT_EQ(cursor->getRowCount(cursor, &count), RDB_OK);
935 EXPECT_EQ(count, 0);
936
937 predicates->destroy(predicates);
938 cursor->destroy(cursor);
939 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_DROP_SQL);
940 EXPECT_EQ(errCode, RDB_OK);
941 }
942
943 /**
944 * @tc.name: RDB_Native_predicates_test_030
945 * @tc.desc: Test using placeholder scenarios.
946 * 1.Execute OH_Predicates_Having(predicates, total > ? AND count >= ?", {5000, 3})
947 * 2.Query data
948 * @tc.type: FUNC
949 */
950 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_030, TestSize.Level1)
951 {
952 auto errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_CREATE_SQL);
953 EXPECT_EQ(errCode, RDB_OK);
954 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_INSERT_SQL);
955 EXPECT_EQ(errCode, RDB_OK);
956
957 OH_Predicates *predicates = OH_Rdb_CreatePredicates("orders");
958 EXPECT_NE(predicates, nullptr);
959 const char *columnNames[] = { "customer_id"};
960 predicates->groupBy(predicates, columnNames, 1);
961 auto values = OH_Values_Create();
962 OH_Values_PutInt(values, 5000);
963 OH_Values_PutInt(values, 3);
964 errCode = OH_Predicates_Having(predicates, "total > ? AND count >= ?", values);
965 EXPECT_EQ(errCode, RDB_OK);
966
967 const char *columnNames1[] = { "customer_id", "COUNT(*) AS count", "SUM(amount) AS total"};
968 // 3 represents the number of columns.
969 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, columnNames1, 3);
970
971 EXPECT_EQ(cursor->goToNextRow(cursor), RDB_OK);
972 int64_t value;
973 EXPECT_EQ(cursor->getInt64(cursor, 0, &value), E_OK);
974 EXPECT_EQ(value, 1);
975 EXPECT_EQ(cursor->getInt64(cursor, 2, &value), E_OK); // 2 represents the total in the third column.
976 EXPECT_EQ(value, 6500); // 6500 means total price.
977
978 EXPECT_EQ(cursor->goToNextRow(cursor), RDB_OK);
979 EXPECT_EQ(cursor->getInt64(cursor, 0, &value), E_OK);
980 EXPECT_EQ(value, 3);
981 EXPECT_EQ(cursor->getInt64(cursor, 2, &value), E_OK); // 2 represents the total in the third column.
982 EXPECT_EQ(value, 7000); // 7000 means total price.
983
984 predicates->destroy(predicates);
985 cursor->destroy(cursor);
986 errCode = OH_Rdb_Execute(predicatesTestRdbStore_, HAVING_DROP_SQL);
987 EXPECT_EQ(errCode, RDB_OK);
988 }
989
990 /**
991 * @tc.name: RDB_Native_predicates_test_031
992 * @tc.desc: Normal testCase of Predicates for notLike.
993 * @tc.type: FUNC
994 */
995 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_031, TestSize.Level1)
996 {
997 int errCode = 0;
998 const char *data5Value = "BBCD%";
999 const char *data2Value = "12%";
1000
1001 auto ret = OH_Predicates_NotLike(nullptr, "data5", data5Value);
1002 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1003
1004 OH_Predicates wrong;
1005 wrong.id = 1;
1006 ret = OH_Predicates_NotLike(&wrong, "data5", data5Value);
1007 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1008
1009 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1010 EXPECT_NE(predicates, nullptr);
1011
1012 ret = OH_Predicates_NotLike(predicates, nullptr, data5Value);
1013 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1014
1015 ret = OH_Predicates_NotLike(predicates, "data5", nullptr);
1016 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1017
1018 ret = OH_Predicates_NotLike(predicates, "data5", data5Value);
1019 ret = OH_Predicates_NotLike(predicates, "data2", data2Value);
1020
1021 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1022 EXPECT_NE(cursor, NULL);
1023 int rowCount = 0;
1024 errCode = cursor->getRowCount(cursor, &rowCount);
1025 EXPECT_EQ(rowCount, 2);
1026
1027 predicates->destroy(predicates);
1028 cursor->destroy(cursor);
1029 }
1030
1031 /**
1032 * @tc.name: RDB_Native_predicates_test_032
1033 * @tc.desc: Normal testCase of Predicates for glob.
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_032, TestSize.Level1)
1037 {
1038 int errCode = 0;
1039 const char *data5Value = "aBCD*";
1040 const char *data5Value2 = "ABCD*";
1041
1042 auto ret = OH_Predicates_Glob(nullptr, "data5", data5Value);
1043 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1044
1045 OH_Predicates wrong;
1046 wrong.id = 1;
1047 ret = OH_Predicates_Glob(&wrong, "data5", data5Value);
1048 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1049
1050 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1051 EXPECT_NE(predicates, nullptr);
1052
1053 ret = OH_Predicates_Glob(predicates, nullptr, data5Value);
1054 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1055
1056 ret = OH_Predicates_Glob(predicates, "data5", nullptr);
1057 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1058
1059 ret = OH_Predicates_Glob(predicates, "data5", data5Value);
1060 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1061 EXPECT_NE(cursor, NULL);
1062 int rowCount = 0;
1063 errCode = cursor->getRowCount(cursor, &rowCount);
1064 EXPECT_EQ(rowCount, 0);
1065 cursor->destroy(cursor);
1066 predicates->destroy(predicates);
1067
1068 predicates = OH_Rdb_CreatePredicates("test");
1069 EXPECT_NE(predicates, nullptr);
1070 ret = OH_Predicates_Glob(predicates, "data5", data5Value2);
1071 cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1072 EXPECT_NE(cursor, NULL);
1073 rowCount = 0;
1074 errCode = cursor->getRowCount(cursor, &rowCount);
1075 EXPECT_EQ(rowCount, 3);
1076 cursor->destroy(cursor);
1077 predicates->destroy(predicates);
1078 }
1079
1080 /**
1081 * @tc.name: RDB_Native_predicates_test_033
1082 * @tc.desc: Normal testCase of Predicates for glob.
1083 * @tc.type: FUNC
1084 */
1085 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_033, TestSize.Level1)
1086 {
1087 int errCode = 0;
1088 const char *data5Value = "aBCD*";
1089 const char *data5Value2 = "ABCD*";
1090
1091 auto ret = OH_Predicates_NotGlob(nullptr, "data5", data5Value);
1092 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1093
1094 OH_Predicates wrong;
1095 wrong.id = 1;
1096 ret = OH_Predicates_NotGlob(&wrong, "data5", data5Value);
1097 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1098
1099 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1100 EXPECT_NE(predicates, nullptr);
1101
1102 ret = OH_Predicates_NotGlob(predicates, nullptr, data5Value);
1103 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1104
1105 ret = OH_Predicates_NotGlob(predicates, "data5", nullptr);
1106 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1107
1108 ret = OH_Predicates_NotGlob(predicates, "data5", data5Value);
1109 OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1110 EXPECT_NE(cursor, NULL);
1111 int rowCount = 0;
1112 errCode = cursor->getRowCount(cursor, &rowCount);
1113 EXPECT_EQ(rowCount, 3);
1114 cursor->destroy(cursor);
1115 predicates->destroy(predicates);
1116
1117 predicates = OH_Rdb_CreatePredicates("test");
1118 EXPECT_NE(predicates, nullptr);
1119 ret = OH_Predicates_NotGlob(predicates, "data5", data5Value2);
1120 cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
1121 EXPECT_NE(cursor, NULL);
1122 rowCount = 0;
1123 errCode = cursor->getRowCount(cursor, &rowCount);
1124 EXPECT_EQ(rowCount, 0);
1125 cursor->destroy(cursor);
1126 predicates->destroy(predicates);
1127 }