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_value_object.h"
24 #include "relational_store.h"
25 #include "relational_store_error_code.h"
26 
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 };
SetUpTestCase(void)51 void RdbNativePredicatesTest::SetUpTestCase(void)
52 {
53     InitRdbConfig();
54     mkdir(config_.dataBaseDir, 0770);
55     int errCode = 0;
56     char table[] = "test";
57     predicatesTestRdbStore_ = OH_Rdb_GetOrOpen(&config_, &errCode);
58     EXPECT_NE(predicatesTestRdbStore_, NULL);
59 
60     char createTableSql[] = "CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
61                             "data3 FLOAT, data4 BLOB, data5 TEXT);";
62     errCode = OH_Rdb_Execute(predicatesTestRdbStore_, createTableSql);
63 
64     OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
65     valueBucket->putInt64(valueBucket, "id", 1);
66     valueBucket->putText(valueBucket, "data1", "zhangSan");
67     valueBucket->putInt64(valueBucket, "data2", 12800);
68     valueBucket->putReal(valueBucket, "data3", 100.1);
69     uint8_t arr[] = { 1, 2, 3, 4, 5 };
70     int len = sizeof(arr) / sizeof(arr[0]);
71     valueBucket->putBlob(valueBucket, "data4", arr, len);
72     valueBucket->putText(valueBucket, "data5", "ABCDEFG");
73     errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
74     EXPECT_EQ(errCode, 1);
75 
76     valueBucket->clear(valueBucket);
77     valueBucket->putInt64(valueBucket, "id", 2);
78     valueBucket->putText(valueBucket, "data1", "liSi");
79     valueBucket->putInt64(valueBucket, "data2", 13800);
80     valueBucket->putReal(valueBucket, "data3", 200.1);
81     valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
82     errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
83     EXPECT_EQ(errCode, 2);
84 
85     valueBucket->clear(valueBucket);
86     valueBucket->putInt64(valueBucket, "id", 3);
87     valueBucket->putText(valueBucket, "data1", "wangWu");
88     valueBucket->putInt64(valueBucket, "data2", 14800);
89     valueBucket->putReal(valueBucket, "data3", 300.1);
90     valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
91     errCode = OH_Rdb_Insert(predicatesTestRdbStore_, table, valueBucket);
92     EXPECT_EQ(errCode, 3);
93 
94     valueBucket->destroy(valueBucket);
95 }
96 
TearDownTestCase(void)97 void RdbNativePredicatesTest::TearDownTestCase(void)
98 {
99     char dropTableSql[] = "DROP TABLE IF EXISTS test";
100     int errCode = OH_Rdb_Execute(predicatesTestRdbStore_, dropTableSql);
101     EXPECT_EQ(errCode, 0);
102     delete predicatesTestRdbStore_;
103     predicatesTestRdbStore_ = NULL;
104     OH_Rdb_DeleteStore(&config_);
105 }
106 
SetUp(void)107 void RdbNativePredicatesTest::SetUp(void)
108 {
109 }
110 
TearDown(void)111 void RdbNativePredicatesTest::TearDown(void)
112 {
113 }
114 
115 /**
116  * @tc.name: RDB_Native_predicates_test_001
117  * @tc.desc: Normal testCase of Predicates for EqualTo、AndOR、beginWrap and endWrap
118  * @tc.type: FUNC
119  */
120 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_001, TestSize.Level1)
121 {
122     int errCode = 0;
123     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
124     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
125     uint32_t count = 1;
126     const char *data1Value = "zhangSan";
127     valueObject->putText(valueObject, data1Value);
128     predicates->beginWrap(predicates)->equalTo(predicates, "data1", valueObject)->orOperate(predicates);
129     double data3Value = 200.1;
130     valueObject->putDouble(valueObject, &data3Value, count);
131     predicates->equalTo(predicates, "data3", valueObject)->endWrap(predicates);
132 
133     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
134     EXPECT_NE(cursor, NULL);
135     int rowCount = 0;
136     errCode = cursor->getRowCount(cursor, &rowCount);
137     EXPECT_EQ(rowCount, 2);
138 
139     valueObject->destroy(valueObject);
140     predicates->destroy(predicates);
141     cursor->destroy(cursor);
142 }
143 
144 /**
145  * @tc.name: RDB_Native_predicates_test_002
146  * @tc.desc: Normal testCase of Predicates for NotEqualTo
147  * @tc.type: FUNC
148  */
149 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_002, TestSize.Level1)
150 {
151     int errCode = 0;
152     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
153     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
154     const char *data1Value = "zhangSan";
155     valueObject->putText(valueObject, data1Value);
156     predicates->notEqualTo(predicates, "data1", valueObject);
157     EXPECT_EQ(errCode, 0);
158 
159     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
160     EXPECT_NE(cursor, NULL);
161     int rowCount = 0;
162     errCode = cursor->getRowCount(cursor, &rowCount);
163     EXPECT_EQ(rowCount, 2);
164 
165     valueObject->destroy(valueObject);
166     predicates->destroy(predicates);
167     cursor->destroy(cursor);
168 }
169 
170 /**
171  * @tc.name: RDB_Native_predicates_test_003
172  * @tc.desc: Normal testCase of Predicates for GreaterThan
173  * @tc.type: FUNC
174  */
175 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_003, TestSize.Level1)
176 {
177     int errCode = 0;
178     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
179     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
180     const char *data5Value = "ABCDEFG";
181     valueObject->putText(valueObject, data5Value);
182     predicates->greaterThan(predicates, "data5", valueObject);
183 
184     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
185     EXPECT_NE(cursor, NULL);
186     int rowCount = 0;
187     errCode = cursor->getRowCount(cursor, &rowCount);
188     EXPECT_EQ(rowCount, 2);
189 
190     cursor->goToNextRow(cursor);
191     int columnCount = 0;
192     cursor->getColumnCount(cursor, &columnCount);
193     EXPECT_EQ(columnCount, 6);
194 
195     int64_t id;
196     cursor->getInt64(cursor, 0, &id);
197     EXPECT_EQ(id, 2);
198 
199     size_t size = 0;
200     cursor->getSize(cursor, 1, &size);
201     char data1Value[size + 1];
202     cursor->getText(cursor, 1, data1Value, size + 1);
203     EXPECT_EQ(strcmp(data1Value, "liSi"), 0);
204 
205     int64_t data2Value;
206     cursor->getInt64(cursor, 2, &data2Value);
207     EXPECT_EQ(data2Value, 13800);
208 
209     double data3Value;
210     cursor->getReal(cursor, 3, &data3Value);
211     EXPECT_EQ(data3Value, 200.1);
212 
213     bool isNull = false;
214     cursor->isNull(cursor, 4, &isNull);
215     EXPECT_EQ(isNull, true);
216 
217     cursor->getSize(cursor, 5, &size);
218     char data5Value_1[size + 1];
219     cursor->getText(cursor, 5, data5Value_1, size + 1);
220     EXPECT_EQ(strcmp(data5Value_1, "ABCDEFGH"), 0);
221 
222     cursor->goToNextRow(cursor);
223     cursor->getInt64(cursor, 0, &id);
224     EXPECT_EQ(id, 3);
225 
226     valueObject->destroy(valueObject);
227     predicates->destroy(predicates);
228     cursor->destroy(cursor);
229 }
230 
231 /**
232  * @tc.name: RDB_Native_predicates_test_004
233  * @tc.desc: Normal testCase of Predicates for GreaterThanOrEqualTo
234  * @tc.type: FUNC
235  */
236 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_004, TestSize.Level1)
237 {
238     int errCode = 0;
239     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
240     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
241     const char *data5Value = "ABCDEFG";
242     valueObject->putText(valueObject, data5Value);
243     predicates->greaterThanOrEqualTo(predicates, "data5", valueObject);
244 
245     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
246     EXPECT_NE(cursor, NULL);
247     int rowCount = 0;
248     errCode = cursor->getRowCount(cursor, &rowCount);
249     EXPECT_EQ(rowCount, 3);
250 
251     valueObject->destroy(valueObject);
252     predicates->destroy(predicates);
253     cursor->destroy(cursor);
254 }
255 
256 /**
257  * @tc.name: RDB_Native_predicates_test_005
258  * @tc.desc: Normal testCase of Predicates for LessThan
259  * @tc.type: FUNC
260  */
261 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_005, TestSize.Level1)
262 {
263     int errCode = 0;
264     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
265     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
266     const char *data5Value = "ABCDEFG";
267     valueObject->putText(valueObject, data5Value);
268     predicates->lessThan(predicates, "data5", valueObject);
269 
270     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
271     EXPECT_NE(cursor, NULL);
272     int rowCount = 0;
273     errCode = cursor->getRowCount(cursor, &rowCount);
274     EXPECT_EQ(rowCount, 0);
275 
276     valueObject->destroy(valueObject);
277     predicates->destroy(predicates);
278     cursor->destroy(cursor);
279 }
280 
281 /**
282  * @tc.name: RDB_Native_predicates_test_006
283  * @tc.desc: Normal testCase of Predicates for LessThanOrEqualTo
284  * @tc.type: FUNC
285  */
286 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_006, TestSize.Level1)
287 {
288     int errCode = 0;
289     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
290     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
291     const char *data5Value = "ABCDEFG";
292     valueObject->putText(valueObject, data5Value);
293     predicates->lessThanOrEqualTo(predicates, "data5", valueObject);
294 
295     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
296     EXPECT_NE(cursor, NULL);
297     int rowCount = 0;
298     errCode = cursor->getRowCount(cursor, &rowCount);
299     EXPECT_EQ(rowCount, 1);
300 
301     valueObject->destroy(valueObject);
302     predicates->destroy(predicates);
303     cursor->destroy(cursor);
304 }
305 
306 /**
307  * @tc.name: RDB_Native_predicates_test_007
308  * @tc.desc: Normal testCase of Predicates for IsNull.
309  * @tc.type: FUNC
310  */
311 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_007, TestSize.Level1)
312 {
313     int errCode = 0;
314     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
315     predicates->isNull(predicates, "data4");
316 
317     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
318     EXPECT_NE(cursor, NULL);
319     int rowCount = 0;
320     errCode = cursor->getRowCount(cursor, &rowCount);
321     EXPECT_EQ(rowCount, 2);
322 
323     predicates->destroy(predicates);
324     cursor->destroy(cursor);
325 }
326 
327 /**
328  * @tc.name: RDB_Native_predicates_test_008
329  * @tc.desc: Normal testCase of Predicates for IsNull.
330  * @tc.type: FUNC
331  */
332 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_008, TestSize.Level1)
333 {
334     int errCode = 0;
335     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
336     predicates->isNotNull(predicates, "data4");
337 
338     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
339     EXPECT_NE(cursor, NULL);
340     int rowCount = 0;
341     errCode = cursor->getRowCount(cursor, &rowCount);
342     EXPECT_EQ(rowCount, 1);
343 
344     predicates->destroy(predicates);
345     cursor->destroy(cursor);
346 }
347 
348 /**
349  * @tc.name: RDB_Native_predicates_test_009
350  * @tc.desc: Normal testCase of Predicates for Between
351  * @tc.type: FUNC
352  */
353 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_009, TestSize.Level1)
354 {
355     int errCode = 0;
356     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
357     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
358     int64_t data2Value[] = { 12000, 13000 };
359     uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
360     valueObject->putInt64(valueObject, data2Value, len);
361     predicates->between(predicates, "data2", valueObject);
362     double data3Value[] = { 0.1, 101.1 };
363     len = sizeof(data3Value) / sizeof(data3Value[0]);
364     valueObject->putDouble(valueObject, data3Value, len);
365     predicates->between(predicates, "data3", valueObject);
366 
367     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
368     EXPECT_NE(cursor, NULL);
369     int rowCount = 0;
370     errCode = cursor->getRowCount(cursor, &rowCount);
371     EXPECT_EQ(rowCount, 1);
372 
373     valueObject->destroy(valueObject);
374     predicates->destroy(predicates);
375     cursor->destroy(cursor);
376 }
377 
378 /**
379  * @tc.name: RDB_Native_predicates_test_010
380  * @tc.desc: Normal testCase of Predicates for NotBetween
381  * @tc.type: FUNC
382  */
383 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_010, TestSize.Level1)
384 {
385     int errCode = 0;
386     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
387     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
388     int64_t data2Value[] = { 12000, 13000 };
389     int len = sizeof(data2Value) / sizeof(data2Value[0]);
390     valueObject->putInt64(valueObject, data2Value, len);
391     predicates->notBetween(predicates, "data2", valueObject);
392 
393     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
394     EXPECT_NE(cursor, NULL);
395     int rowCount = 0;
396     errCode = cursor->getRowCount(cursor, &rowCount);
397     EXPECT_EQ(rowCount, 2);
398 
399     valueObject->destroy(valueObject);
400     predicates->destroy(predicates);
401     cursor->destroy(cursor);
402 }
403 
404 /**
405  * @tc.name: RDB_Native_predicates_test_011
406  * @tc.desc: Normal testCase of Predicates for OrderBy、Limit、Offset.
407  * @tc.type: FUNC
408  */
409 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_011, TestSize.Level1)
410 {
411     int errCode = 0;
412     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
413     predicates->orderBy(predicates, "data2", OH_OrderType::ASC);
414     predicates->limit(predicates, 1);
415     predicates->offset(predicates, 1);
416     predicates->distinct(predicates);
417 
418     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
419     EXPECT_NE(cursor, NULL);
420     int rowCount = 0;
421     errCode = cursor->getRowCount(cursor, &rowCount);
422     EXPECT_EQ(rowCount, 1);
423 
424     errCode = cursor->goToNextRow(cursor);
425     int columnIndex;
426     cursor->getColumnIndex(cursor, "data2", &columnIndex);
427     EXPECT_EQ(columnIndex, 2);
428     int64_t longValue;
429     cursor->getInt64(cursor, columnIndex, &longValue);
430     EXPECT_EQ(longValue, 13800);
431 
432     predicates->destroy(predicates);
433     cursor->destroy(cursor);
434 }
435 
436 /**
437  * @tc.name: RDB_Native_predicates_test_012
438  * @tc.desc: Normal testCase of Predicates for In.
439  * @tc.type: FUNC
440  */
441 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_012, TestSize.Level1)
442 {
443     int errCode = 0;
444     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
445     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
446     const char *data1Value[] = { "zhangSan", "liSi" };
447     int len = sizeof(data1Value) / sizeof(data1Value[0]);
448     valueObject->putTexts(valueObject, data1Value, len);
449     predicates->in(predicates, "data1", valueObject);
450 
451     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
452     EXPECT_NE(cursor, NULL);
453     int rowCount = 0;
454     errCode = cursor->getRowCount(cursor, &rowCount);
455     EXPECT_EQ(rowCount, 2);
456 
457     valueObject->destroy(valueObject);
458     predicates->destroy(predicates);
459     cursor->destroy(cursor);
460 }
461 
462 /**
463  * @tc.name: RDB_Native_predicates_test_013
464  * @tc.desc: Normal testCase of Predicates for NotIn.
465  * @tc.type: FUNC
466  */
467 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_013, TestSize.Level1)
468 {
469     int errCode = 0;
470     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
471     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
472     const char *data1Value[] = { "zhangSan", "liSi" };
473     int len = sizeof(data1Value) / sizeof(data1Value[0]);
474     valueObject->putTexts(valueObject, data1Value, len);
475     predicates->notIn(predicates, "data1", valueObject);
476 
477     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
478     EXPECT_NE(cursor, NULL);
479     int rowCount = 0;
480     errCode = cursor->getRowCount(cursor, &rowCount);
481     EXPECT_EQ(rowCount, 1);
482 
483     valueObject->destroy(valueObject);
484     predicates->destroy(predicates);
485     cursor->destroy(cursor);
486 }
487 
488 /**
489  * @tc.name: RDB_Native_predicates_test_014
490  * @tc.desc: Normal testCase of Predicates for Like.
491  * @tc.type: FUNC
492  */
493 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_014, TestSize.Level1)
494 {
495     int errCode = 0;
496     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
497     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
498     const char *data5Value = "ABCD%";
499     valueObject->putText(valueObject, data5Value);
500     predicates->like(predicates, "data5", valueObject);
501     const char *data2Value = "%800";
502     valueObject->putText(valueObject, data2Value);
503     predicates->like(predicates, "data2", valueObject);
504 
505     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
506     EXPECT_NE(cursor, NULL);
507     int rowCount = 0;
508     errCode = cursor->getRowCount(cursor, &rowCount);
509     EXPECT_EQ(rowCount, 3);
510 
511     valueObject->destroy(valueObject);
512     predicates->destroy(predicates);
513     cursor->destroy(cursor);
514 }
515 
516 /**
517  * @tc.name: RDB_Native_predicates_test_015
518  * @tc.desc: Normal testCase of Predicates for GroupBy.
519  * @tc.type: FUNC
520  */
521 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_015, TestSize.Level1)
522 {
523     int errCode = 0;
524     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
525     const char *columnNames[] = { "data1", "data2" };
526     int len = sizeof(columnNames) / sizeof(columnNames[0]);
527     predicates->groupBy(predicates, columnNames, len);
528 
529     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
530     EXPECT_NE(cursor, NULL);
531     int rowCount = 0;
532     errCode = cursor->getRowCount(cursor, &rowCount);
533     EXPECT_EQ(rowCount, 3);
534 
535     predicates->destroy(predicates);
536     cursor->destroy(cursor);
537 }
538 
539 /**
540  * @tc.name: RDB_Native_predicates_test_016
541  * @tc.desc: Normal testCase of Predicates for And.
542  * @tc.type: FUNC
543  */
544 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_016, TestSize.Level1)
545 {
546     int errCode = 0;
547     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
548     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
549     const char *data1Value = "zhangSan";
550     valueObject->putText(valueObject, data1Value);
551     predicates->equalTo(predicates, "data1", valueObject);
552     predicates->andOperate(predicates);
553     double data3Value = 100.1;
554     valueObject->putDouble(valueObject, &data3Value, 1);
555     predicates->equalTo(predicates, "data3", valueObject);
556 
557     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
558     EXPECT_NE(cursor, NULL);
559     int rowCount = 0;
560     errCode = cursor->getRowCount(cursor, &rowCount);
561     EXPECT_EQ(rowCount, 1);
562 
563     valueObject->destroy(valueObject);
564     predicates->destroy(predicates);
565     errCode = cursor->destroy(cursor);
566 }
567 
568 /**
569  * @tc.name: RDB_Native_predicates_test_017
570  * @tc.desc: Normal testCase of Predicates for Clear.
571  * @tc.type: FUNC
572  */
573 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_017, TestSize.Level1)
574 {
575     int errCode = 0;
576     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
577     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
578     const char *data1Value = "zhangSan";
579     valueObject->putText(valueObject, data1Value);
580     predicates->equalTo(predicates, "data1", valueObject);
581 
582     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
583     EXPECT_NE(cursor, NULL);
584     int rowCount = 0;
585     errCode = cursor->getRowCount(cursor, &rowCount);
586     EXPECT_EQ(rowCount, 1);
587     errCode = cursor->destroy(cursor);
588 
589     predicates->clear(predicates);
590     predicates->notEqualTo(predicates, "data1", valueObject);
591     cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
592     EXPECT_NE(cursor, NULL);
593     errCode = cursor->getRowCount(cursor, &rowCount);
594     EXPECT_EQ(rowCount, 2);
595 
596     valueObject->destroy(valueObject);
597     predicates->destroy(predicates);
598     cursor->destroy(cursor);
599 }
600 /**
601  * @tc.name: RDB_Native_predicates_test_018
602  * @tc.desc: Normal testCase of Predicates for table name is NULL.
603  * @tc.type: FUNC
604  */
605 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_018, TestSize.Level1)
606 {
607     char *table = NULL;
608     OH_Predicates *predicates = OH_Rdb_CreatePredicates(table);
609     EXPECT_EQ(predicates, NULL);
610 
611     OH_Cursor *cursor = OH_Rdb_Query(predicatesTestRdbStore_, predicates, NULL, 0);
612     EXPECT_EQ(cursor, NULL);
613 }
614 
615 /**
616  * @tc.name: RDB_Native_predicates_test_019
617  * @tc.desc: Normal testCase of Predicates for anomalous branch.
618  * @tc.type: FUNC
619  */
620 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_019, TestSize.Level1)
621 {
622     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
623     EXPECT_NE(predicates, NULL);
624 
625     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
626     const char *data1Value = "zhangSan";
627     valueObject->putText(valueObject, data1Value);
628     predicates->equalTo(nullptr, "data1", valueObject);
629     predicates->equalTo(predicates, nullptr, valueObject);
630     predicates->equalTo(predicates, "data1", nullptr);
631     predicates->notEqualTo(nullptr, "data1", valueObject);
632     predicates->notEqualTo(predicates, nullptr, valueObject);
633     predicates->notEqualTo(predicates, "data1", nullptr);
634 
635     predicates->beginWrap(nullptr);
636     predicates->endWrap(nullptr);
637 
638     predicates->orOperate(nullptr);
639     predicates->andOperate(nullptr);
640 
641     predicates->isNull(nullptr, "data4");
642     predicates->isNull(predicates, nullptr);
643     predicates->isNotNull(nullptr, "data4");
644     predicates->isNotNull(predicates, nullptr);
645 
646     const char *data5ValueLike = "ABCD%";
647     valueObject->putText(valueObject, data5ValueLike);
648     predicates->like(nullptr, "data5", valueObject);
649     predicates->like(predicates, nullptr, valueObject);
650     predicates->like(predicates, "data5", nullptr);
651 
652     int64_t data2Value[] = { 12000, 13000 };
653     uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
654     valueObject->putInt64(valueObject, data2Value, len);
655     predicates->between(nullptr, "data2", valueObject);
656     predicates->between(predicates, nullptr, valueObject);
657     predicates->between(predicates, "data2", nullptr);
658     predicates->notBetween(nullptr, "data2", valueObject);
659     predicates->notBetween(predicates, nullptr, valueObject);
660     predicates->notBetween(predicates, "data2", nullptr);
661     int64_t data2Value_1[] = { 12000 };
662     len = sizeof(data2Value_1) / sizeof(data2Value_1[0]);
663     valueObject->putInt64(valueObject, data2Value_1, len);
664     predicates->between(predicates, "data2", valueObject);
665     predicates->notBetween(predicates, "data2", valueObject);
666 
667     valueObject->destroy(valueObject);
668     predicates->destroy(predicates);
669 }
670 
671 /**
672  * @tc.name: RDB_Native_predicates_test_020
673  * @tc.desc: Normal testCase of Predicates for anomalous branch.
674  * @tc.type: FUNC
675  */
676 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_020, TestSize.Level1)
677 {
678     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
679     EXPECT_NE(predicates, NULL);
680 
681     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
682     const char *data1Value = "zhangSan";
683     valueObject->putText(valueObject, data1Value);
684 
685     const char *data5Value = "ABCDEFG";
686     valueObject->putText(valueObject, data5Value);
687     predicates->greaterThan(nullptr, "data5", valueObject);
688     predicates->greaterThan(predicates, nullptr, valueObject);
689     predicates->greaterThan(predicates, "data5", nullptr);
690     predicates->lessThan(nullptr, "data5", valueObject);
691     predicates->lessThan(predicates, nullptr, valueObject);
692     predicates->lessThan(predicates, "data5", nullptr);
693     predicates->greaterThanOrEqualTo(nullptr, "data5", valueObject);
694     predicates->greaterThanOrEqualTo(predicates, nullptr, valueObject);
695     predicates->greaterThanOrEqualTo(predicates, "data5", nullptr);
696     predicates->lessThanOrEqualTo(nullptr, "data5", valueObject);
697     predicates->lessThanOrEqualTo(predicates, nullptr, valueObject);
698     predicates->lessThanOrEqualTo(predicates, "data5", nullptr);
699 
700     predicates->orderBy(nullptr, "data2", OH_OrderType::ASC);
701     predicates->orderBy(predicates, nullptr, OH_OrderType::ASC);
702 
703     predicates->distinct(nullptr);
704     predicates->limit(nullptr, 1);
705     predicates->offset(nullptr, 1);
706 
707     const char *columnNames[] = { "data1", "data2" };
708     uint32_t len = sizeof(columnNames) / sizeof(columnNames[0]);
709     predicates->groupBy(nullptr, columnNames, len);
710     predicates->groupBy(predicates, nullptr, len);
711     predicates->groupBy(predicates, columnNames, 0);
712 
713     const char *data1ValueIn[] = { "zhangSan", "liSi" };
714     len = sizeof(data1ValueIn) / sizeof(data1ValueIn[0]);
715     valueObject->putTexts(valueObject, data1ValueIn, len);
716     predicates->in(nullptr, "data1", valueObject);
717     predicates->in(predicates, nullptr, valueObject);
718     predicates->in(predicates, "data1", nullptr);
719     predicates->notIn(nullptr, "data1", valueObject);
720     predicates->notIn(predicates, nullptr, valueObject);
721     predicates->notIn(predicates, "data1", nullptr);
722 
723     predicates->clear(nullptr);
724     int errCode = predicates->destroy(nullptr);
725     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
726     valueObject->destroy(valueObject);
727     predicates->destroy(predicates);
728 }
729 
730 /**
731  * @tc.name: RDB_Native_predicates_test_021
732  * @tc.desc: Normal testCase of RelationalPredicatesObjects for anomalous branch.
733  * @tc.type: FUNC
734  */
735 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_021, TestSize.Level1)
736 {
737     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
738     int64_t data2Value[] = { 12000, 13000 };
739     uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
740     int errCode = valueObject->putInt64(nullptr, data2Value, len);
741     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
742     errCode = valueObject->putInt64(valueObject, nullptr, len);
743     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
744     errCode = valueObject->putInt64(valueObject, data2Value, 0);
745     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
746 
747     uint32_t count = 1;
748     double data3Value = 200.1;
749     errCode = valueObject->putDouble(nullptr, &data3Value, count);
750     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
751     errCode = valueObject->putDouble(valueObject, nullptr, count);
752     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
753     errCode = valueObject->putDouble(valueObject, &data3Value, 0);
754     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
755 
756     const char *data1Value = "zhangSan";
757     valueObject->putText(nullptr, data1Value);
758     valueObject->putText(valueObject, nullptr);
759 
760     const char *data1ValueTexts[] = { "zhangSan", "liSi" };
761     len = sizeof(data1ValueTexts) / sizeof(data1ValueTexts[0]);
762     errCode = valueObject->putTexts(nullptr, data1ValueTexts, len);
763     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
764     errCode = valueObject->putTexts(valueObject, nullptr, len);
765     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
766     errCode = valueObject->putTexts(valueObject, data1ValueTexts, 0);
767     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
768 
769     errCode = valueObject->destroy(nullptr);
770     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
771     valueObject->destroy(valueObject);
772 }