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 */
15
16 #include "rdb_predicates.h"
17
18 #include <gtest/gtest.h>
19 #include <sys/stat.h>
20 #include <sys/types.h>
21 #include <unistd.h>
22
23 #include <algorithm>
24 #include <climits>
25 #include <ctime>
26 #include <sstream>
27 #include <string>
28 #include <vector>
29
30 #include "abs_rdb_predicates.h"
31 #include "common.h"
32 #include "rdb_errno.h"
33 #include "rdb_helper.h"
34 #include "rdb_open_callback.h"
35
36 using namespace testing::ext;
37 using namespace OHOS::NativeRdb;
38
39 class AllDataType {
40 public:
GetId() const41 int GetId() const
42 {
43 return id;
44 }
45
SetId(int id)46 void SetId(int id)
47 {
48 this->id = id;
49 }
50
GetIntegerValue() const51 int GetIntegerValue() const
52 {
53 return integerValue;
54 }
55
SetIntegerValue(int integerValue)56 void SetIntegerValue(int integerValue)
57 {
58 this->integerValue = integerValue;
59 }
60
GetLongValue() const61 int64_t GetLongValue() const
62 {
63 return longValue;
64 }
65
SetLongValue(int64_t longValue)66 void SetLongValue(int64_t longValue)
67 {
68 this->longValue = longValue;
69 }
70
GetShortValue() const71 short GetShortValue() const
72 {
73 return shortValue;
74 }
75
SetShortValue(short shortValue)76 void SetShortValue(short shortValue)
77 {
78 this->shortValue = shortValue;
79 }
80
GetBooleanValue() const81 bool GetBooleanValue() const
82 {
83 return booleanValue;
84 }
85
SetBooleanValue(bool booleanValue)86 void SetBooleanValue(bool booleanValue)
87 {
88 this->booleanValue = booleanValue;
89 }
90
GetDoubleValue() const91 double GetDoubleValue() const
92 {
93 return doubleValue;
94 }
95
SetDoubleValue(double doubleValue)96 void SetDoubleValue(double doubleValue)
97 {
98 this->doubleValue = doubleValue;
99 }
100
GetFloatValue() const101 float GetFloatValue() const
102 {
103 return floatValue;
104 }
105
SetFloatValue(float floatValue)106 void SetFloatValue(float floatValue)
107 {
108 this->floatValue = floatValue;
109 }
110
GetStringValue() const111 std::string GetStringValue() const
112 {
113 return stringValue;
114 }
115
SetStringValue(std::string stringValue)116 void SetStringValue(std::string stringValue)
117 {
118 this->stringValue = stringValue;
119 }
120
GetBlobValue() const121 std::vector<uint8_t> GetBlobValue() const
122 {
123 return blobValue;
124 }
125
SetBlobValue(std::vector<uint8_t> blobValue)126 void SetBlobValue(std::vector<uint8_t> blobValue)
127 {
128 this->blobValue = blobValue;
129 }
130
GetClobValue() const131 std::string GetClobValue() const
132 {
133 return clobValue;
134 }
135
SetClobValue(std::string clobValue)136 void SetClobValue(std::string clobValue)
137 {
138 this->clobValue = clobValue;
139 }
140
GetByteValue() const141 int8_t GetByteValue() const
142 {
143 return byteValue;
144 }
145
SetByteValue(int8_t byteValue)146 void SetByteValue(int8_t byteValue)
147 {
148 this->byteValue = byteValue;
149 }
150
GetTimeValue() const151 time_t GetTimeValue() const
152 {
153 return timeValue;
154 }
155
SetTimeValue(time_t timeValue)156 void SetTimeValue(time_t timeValue)
157 {
158 this->timeValue = timeValue;
159 }
160
GetCharacterValue() const161 char GetCharacterValue() const
162 {
163 return characterValue;
164 }
165
SetCharacterValue(char characterValue)166 void SetCharacterValue(char characterValue)
167 {
168 this->characterValue = characterValue;
169 }
170
GetPrimIntValue() const171 int GetPrimIntValue() const
172 {
173 return primIntValue;
174 }
175
SetPrimIntValue(int primIntValue)176 void SetPrimIntValue(int primIntValue)
177 {
178 this->primIntValue = primIntValue;
179 }
180
GetPrimLongValue() const181 int64_t GetPrimLongValue() const
182 {
183 return primLongValue;
184 }
185
SetPrimLongValue(int64_t primLongValue)186 void SetPrimLongValue(int64_t primLongValue)
187 {
188 this->primLongValue = primLongValue;
189 }
190
GetPrimShortValue() const191 short GetPrimShortValue() const
192 {
193 return primShortValue;
194 }
195
SetPrimShortValue(short primShortValue)196 void SetPrimShortValue(short primShortValue)
197 {
198 this->primShortValue = primShortValue;
199 }
200
GetPrimFloatValue() const201 float GetPrimFloatValue() const
202 {
203 return primFloatValue;
204 }
205
SetPrimFloatValue(float primFloatValue)206 void SetPrimFloatValue(float primFloatValue)
207 {
208 this->primFloatValue = primFloatValue;
209 }
210
GetPrimDoubleValue() const211 double GetPrimDoubleValue() const
212 {
213 return primDoubleValue;
214 }
215
SetPrimDoubleValue(double primDoubleValue)216 void SetPrimDoubleValue(double primDoubleValue)
217 {
218 this->primDoubleValue = primDoubleValue;
219 }
220
IsPrimBooleanValue() const221 bool IsPrimBooleanValue() const
222 {
223 return primBooleanValue;
224 }
225
SetPrimBooleanValue(bool primBooleanValue)226 void SetPrimBooleanValue(bool primBooleanValue)
227 {
228 this->primBooleanValue = primBooleanValue;
229 }
230
GetPrimByteValue() const231 int8_t GetPrimByteValue() const
232 {
233 return primByteValue;
234 }
235
SetPrimByteValue(int8_t primByteValue)236 void SetPrimByteValue(int8_t primByteValue)
237 {
238 this->primByteValue = primByteValue;
239 }
240
GetPrimCharValue() const241 char GetPrimCharValue() const
242 {
243 return primCharValue;
244 }
245
SetPrimCharValue(char primCharValue)246 void SetPrimCharValue(char primCharValue)
247 {
248 this->primCharValue = primCharValue;
249 }
250
GetOrder() const251 int GetOrder() const
252 {
253 return order;
254 }
255
SetOrder(int order)256 void SetOrder(int order)
257 {
258 this->order = order;
259 }
260
261 private:
262 int id;
263
264 int integerValue;
265
266 int64_t longValue;
267
268 short shortValue;
269
270 bool booleanValue = false;
271
272 double doubleValue;
273
274 float floatValue;
275
276 std::string stringValue;
277
278 std::vector<uint8_t> blobValue;
279
280 std::string clobValue;
281
282 int8_t byteValue;
283
284 time_t timeValue;
285
286 int primIntValue;
287
288 char characterValue;
289
290 int64_t primLongValue;
291
292 short primShortValue;
293
294 float primFloatValue;
295
296 double primDoubleValue;
297
298 bool primBooleanValue = false;
299
300 int8_t primByteValue;
301
302 char primCharValue;
303
304 int order;
305 };
306
307 class RdbStorePredicateTest : public testing::Test {
308 public:
309 static void SetUpTestCase(void);
310 static void TearDownTestCase(void);
311 void SetUp();
312 void TearDown();
313
314 static const std::string DATABASE_NAME;
315 static std::shared_ptr<RdbStore> store;
316
317 time_t DateMakeTime(std::vector<int> data);
318 void InsertDates(std::vector<AllDataType> dataTypes);
319 AllDataType BuildAllDataType1();
320 AllDataType BuildAllDataType2();
321 AllDataType BuildAllDataType3();
322 void GenerateAllDataTypeTable();
323 void CalendarTest(RdbPredicates predicates1);
324 void BasicDataTypeTest(RdbPredicates predicates1);
325 int ResultSize(std::shared_ptr<ResultSet> &resultSet);
326 void BasicDataTypeTest002(RdbPredicates predicates1);
327 void CalendarTest002(RdbPredicates predicates1);
328 void SetJionList(RdbPredicates &predicates1);
329 };
330
331 std::shared_ptr<RdbStore> RdbStorePredicateTest::store = nullptr;
332 const std::string RdbStorePredicateTest::DATABASE_NAME = RDB_TEST_PATH + "predicates_test.db";
333 const std::string CREATE_TABLE_ALL_DATA_TYPE_SQL =
334 "CREATE TABLE IF NOT EXISTS AllDataType "
335 "(id INTEGER PRIMARY KEY AUTOINCREMENT, integerValue INTEGER , longValue INTEGER , "
336 "shortValue INTEGER , booleanValue INTEGER , doubleValue REAL , floatValue REAL , "
337 "stringValue TEXT , blobValue BLOB , clobValue TEXT , byteValue INTEGER , "
338 "timeValue INTEGER , characterValue TEXT , primIntValue INTEGER ,"
339 "primLongValue INTEGER NOT NULL, primShortValue INTEGER NOT NULL, "
340 "primFloatValue REAL NOT NULL, primDoubleValue REAL NOT NULL, "
341 "primBooleanValue INTEGER NOT NULL, primByteValue INTEGER NOT NULL, "
342 "primCharValue TEXT, `orderr` INTEGER);";
343
344 const std::string CREATE_TABLE_PERSON_SQL =
345 "CREATE TABLE IF NOT EXISTS person "
346 "(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT , age INTEGER , REAL INTEGER, attachments ASSETS,"
347 "attachment ASSET);";
348
349 const std::string ALL_DATA_TYPE_INSERT_SQL =
350 "INSERT INTO AllDataType (id, integerValue, longValue, "
351 "shortValue, booleanValue, doubleValue, floatValue, stringValue, blobValue, "
352 "clobValue, byteValue, timeValue, characterValue, primIntValue, primLongValue, "
353 "primShortValue, primFloatValue, primDoubleValue, "
354 "primBooleanValue, primByteValue, primCharValue, `orderr`) "
355 "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
356
357 class PredicateTestOpenCallback : public RdbOpenCallback {
358 public:
359 int OnCreate(RdbStore &store) override;
360 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
361 };
362
OnCreate(RdbStore & store)363 int PredicateTestOpenCallback::OnCreate(RdbStore &store)
364 {
365 return E_OK;
366 }
367
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)368 int PredicateTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
369 {
370 return E_OK;
371 }
372
SetUpTestCase()373 void RdbStorePredicateTest::SetUpTestCase()
374 {
375 }
376
TearDownTestCase()377 void RdbStorePredicateTest::TearDownTestCase()
378 {
379 RdbHelper::DeleteRdbStore(RdbStorePredicateTest::DATABASE_NAME);
380 }
381
SetUp()382 void RdbStorePredicateTest::SetUp()
383 {
384 if (access(RdbStorePredicateTest::DATABASE_NAME.c_str(), F_OK) != 0) {
385 remove(RdbStorePredicateTest::DATABASE_NAME.c_str());
386 }
387
388 int errCode = E_OK;
389 RdbStoreConfig config(RdbStorePredicateTest::DATABASE_NAME);
390 PredicateTestOpenCallback helper;
391 RdbStorePredicateTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
392 EXPECT_NE(RdbStorePredicateTest::store, nullptr);
393
394 RdbStorePredicateTest::GenerateAllDataTypeTable();
395 }
396
TearDown(void)397 void RdbStorePredicateTest::TearDown(void)
398 {
399 }
400
GenerateAllDataTypeTable()401 void RdbStorePredicateTest::GenerateAllDataTypeTable()
402 {
403 RdbStorePredicateTest::store->ExecuteSql(CREATE_TABLE_ALL_DATA_TYPE_SQL);
404 RdbStorePredicateTest::store->ExecuteSql(CREATE_TABLE_PERSON_SQL);
405
406 AllDataType dataType1 = RdbStorePredicateTest::BuildAllDataType1();
407 AllDataType dataType2 = RdbStorePredicateTest::BuildAllDataType2();
408 AllDataType dataType3 = RdbStorePredicateTest::BuildAllDataType3();
409
410 std::vector<AllDataType> dataTypes;
411 dataTypes.push_back(dataType1);
412 dataTypes.push_back(dataType2);
413 dataTypes.push_back(dataType3);
414 RdbStorePredicateTest::InsertDates(dataTypes);
415 }
416
BuildAllDataType1()417 AllDataType RdbStorePredicateTest::RdbStorePredicateTest::BuildAllDataType1()
418 {
419 std::vector<uint8_t> blob = { 1, 2, 3 };
420 AllDataType dataType;
421 dataType.SetId(1); // 1 means Id of the AllDataType object is 1
422 dataType.SetIntegerValue(INT_MAX);
423 dataType.SetDoubleValue(DBL_MAX);
424 dataType.SetBooleanValue(true);
425 dataType.SetFloatValue(FLT_MAX);
426 dataType.SetLongValue(LONG_MAX);
427 dataType.SetShortValue(SHRT_MAX);
428 dataType.SetCharacterValue(' ');
429 dataType.SetStringValue("ABCDEFGHIJKLMN");
430 dataType.SetBlobValue(blob);
431 dataType.SetClobValue("ABCDEFGHIJKLMN");
432 dataType.SetByteValue(INT8_MAX);
433
434 std::vector<int> date = { 2019, 7, 10 };
435 time_t timeValue = RdbStorePredicateTest::DateMakeTime(date);
436 dataType.SetTimeValue(timeValue);
437
438 dataType.SetPrimIntValue(INT_MAX);
439 dataType.SetPrimDoubleValue(DBL_MAX);
440 dataType.SetPrimFloatValue(FLT_MAX);
441 dataType.SetPrimBooleanValue(true);
442 dataType.SetPrimByteValue(INT8_MAX);
443 dataType.SetPrimCharValue(' ');
444 dataType.SetPrimLongValue(LONG_MAX);
445 dataType.SetPrimShortValue(SHRT_MAX);
446 return dataType;
447 }
448
BuildAllDataType2()449 AllDataType RdbStorePredicateTest::BuildAllDataType2()
450 {
451 std::vector<uint8_t> blob = { 1, 2, 3 };
452 AllDataType dataType2;
453 dataType2.SetId(2); // 2 means Id of the AllDataType object is 2
454 dataType2.SetIntegerValue(1);
455 dataType2.SetDoubleValue(1.0);
456 dataType2.SetBooleanValue(false);
457 dataType2.SetFloatValue(1.0);
458 dataType2.SetLongValue(static_cast<int64_t>(1));
459 dataType2.SetShortValue(static_cast<short>(1));
460 dataType2.SetCharacterValue(' ');
461 dataType2.SetStringValue("ABCDEFGHIJKLMN");
462 dataType2.SetBlobValue(blob);
463 dataType2.SetClobValue("ABCDEFGHIJKLMN");
464 dataType2.SetByteValue(INT8_MIN);
465
466 std::vector<int> date = { 2019, 7, 17 };
467 time_t timeValue2 = RdbStorePredicateTest::DateMakeTime(date);
468 dataType2.SetTimeValue(timeValue2);
469
470 dataType2.SetPrimIntValue(1);
471 dataType2.SetPrimDoubleValue(1.0);
472 dataType2.SetPrimFloatValue(1.0);
473 dataType2.SetPrimBooleanValue(false);
474 dataType2.SetPrimByteValue(static_cast<char>(1));
475 dataType2.SetPrimCharValue(' ');
476 dataType2.SetPrimLongValue(static_cast<int64_t>(1));
477 dataType2.SetPrimShortValue(static_cast<short>(1));
478 return dataType2;
479 }
480
BuildAllDataType3()481 AllDataType RdbStorePredicateTest::BuildAllDataType3()
482 {
483 std::vector<uint8_t> blob = { 1, 2, 3 };
484 AllDataType dataType3;
485 dataType3.SetId(3); // 3 means Id of the AllDataType object is 3
486 dataType3.SetIntegerValue(INT_MIN);
487 dataType3.SetDoubleValue(DBL_MIN);
488 dataType3.SetBooleanValue(false);
489 dataType3.SetFloatValue(FLT_MIN);
490 dataType3.SetLongValue(LONG_MIN);
491 dataType3.SetShortValue(SHRT_MIN);
492 dataType3.SetCharacterValue(' ');
493 dataType3.SetStringValue("ABCDEFGHIJKLMN");
494 dataType3.SetBlobValue(blob);
495 dataType3.SetClobValue("ABCDEFGHIJKLMN");
496 dataType3.SetByteValue(INT8_MIN);
497
498 std::vector<int> date = { 2019, 6, 10 };
499 time_t timeValue3 = RdbStorePredicateTest::DateMakeTime(date);
500 dataType3.SetTimeValue(timeValue3);
501
502 dataType3.SetPrimIntValue(INT_MIN);
503 dataType3.SetPrimDoubleValue(DBL_MIN);
504 dataType3.SetPrimFloatValue(FLT_MIN);
505 dataType3.SetPrimBooleanValue(false);
506 dataType3.SetPrimByteValue(INT8_MIN);
507 dataType3.SetPrimCharValue(' ');
508 dataType3.SetPrimLongValue(LONG_MIN);
509 dataType3.SetPrimShortValue(SHRT_MIN);
510 return dataType3;
511 }
512
InsertDates(std::vector<AllDataType> dataTypes)513 void RdbStorePredicateTest::InsertDates(std::vector<AllDataType> dataTypes)
514 {
515 for (size_t i = 0; i < dataTypes.size(); i++) {
516 char characterValue = dataTypes[i].GetCharacterValue();
517 char primCharValue = dataTypes[i].GetPrimCharValue();
518 std::stringstream strByte;
519 std::vector<ValueObject> objects;
520 objects.push_back(ValueObject(dataTypes[i].GetId()));
521 objects.push_back(ValueObject(dataTypes[i].GetIntegerValue()));
522 objects.push_back(ValueObject(dataTypes[i].GetLongValue()));
523 objects.push_back(ValueObject(dataTypes[i].GetShortValue()));
524 objects.push_back(ValueObject(dataTypes[i].GetBooleanValue()));
525
526 strByte << dataTypes[i].GetDoubleValue();
527 objects.push_back(ValueObject(strByte.str()));
528
529 strByte.str("");
530 strByte << dataTypes[i].GetFloatValue();
531 objects.push_back(ValueObject(strByte.str()));
532 objects.push_back(ValueObject(dataTypes[i].GetStringValue()));
533 objects.push_back(ValueObject(dataTypes[i].GetBlobValue()));
534 objects.push_back(ValueObject(dataTypes[i].GetClobValue()));
535 objects.push_back(ValueObject(dataTypes[i].GetByteValue()));
536 objects.push_back(ValueObject(static_cast<int64_t>(dataTypes[i].GetTimeValue())));
537
538 strByte.str("");
539 strByte << characterValue;
540 string str1 = strByte.str();
541 objects.push_back(ValueObject(str1));
542 objects.push_back(ValueObject(dataTypes[i].GetPrimIntValue()));
543 objects.push_back(ValueObject(dataTypes[i].GetPrimLongValue()));
544 objects.push_back(ValueObject(dataTypes[i].GetPrimShortValue()));
545
546 strByte.str("");
547 strByte << dataTypes[i].GetPrimFloatValue();
548 objects.push_back(ValueObject(strByte.str()));
549
550 strByte.str("");
551 strByte << dataTypes[i].GetPrimDoubleValue();
552 objects.push_back(ValueObject(strByte.str()));
553 objects.push_back(ValueObject(dataTypes[i].IsPrimBooleanValue() ? (char)1 : (char)0));
554 objects.push_back(ValueObject(dataTypes[i].GetPrimByteValue()));
555
556 strByte.str("");
557 strByte << primCharValue;
558 string str2 = strByte.str();
559 objects.push_back(ValueObject(str2));
560 objects.push_back(ValueObject());
561 RdbStorePredicateTest::store->ExecuteSql(ALL_DATA_TYPE_INSERT_SQL, objects);
562 }
563 }
564
DateMakeTime(std::vector<int> data)565 time_t RdbStorePredicateTest::DateMakeTime(std::vector<int> data)
566 {
567 struct tm t1 = { 0 };
568 t1.tm_year = data[0] - 1990;
569 t1.tm_mon = data[1] - 1;
570 t1.tm_hour = data[2];
571 t1.tm_sec = 0;
572 t1.tm_min = 0;
573 t1.tm_mday = 0;
574 time_t time = mktime(&t1);
575 return time;
576 }
577
578 /* *
579 * @tc.name: RdbStore_RdbPredicates_001
580 * @tc.desc: Abnormal testCase of RdbPredicates, if tableName is ""
581 * @tc.type: FUNC
582 */
583 HWTEST_F(RdbStorePredicateTest, RdbStore_RdbPredicates_001, TestSize.Level1)
584 {
585 AbsRdbPredicates predicates("");
586 predicates.EqualTo("integerValue", "1");
587 std::vector<std::string> columns;
588 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
589 EXPECT_EQ(0, ResultSize(allDataTypes));
590 allDataTypes->Close();
591
592 // if predicates HasSpecificField
593 predicates.OrderByAsc("#_number");
594 bool hasSpecificField = predicates.HasSpecificField();
595 EXPECT_EQ(true, hasSpecificField);
596 std::shared_ptr<AbsSharedResultSet> resultSet = RdbStorePredicateTest::store->Query(predicates, columns);
597 EXPECT_NE(nullptr, resultSet);
598 resultSet->Close();
599 }
600
601 /* *
602 * @tc.name: RdbStore_RdbPredicates_002
603 * @tc.desc: Abnormal testCase of RdbPredicates, if tableNames is [] or counts is rather than 1
604 * @tc.type: FUNC
605 */
606 HWTEST_F(RdbStorePredicateTest, RdbStore_RdbPredicates_002, TestSize.Level1)
607 {
608 std::vector<std::string> tableEmpty;
609 std::vector<std::string> tables({ "AllDataType", "person" });
610
611 AbsRdbPredicates predicates1(tableEmpty);
612 AbsRdbPredicates predicates2(tables);
613 predicates2.EqualTo("id", "1");
614 std::vector<std::string> columns;
615 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates2, columns);
616 EXPECT_EQ(1, ResultSize(allDataTypes));
617 allDataTypes->Close();
618 }
619
620 /* *
621 * @tc.name: RdbStore_EqualTo_001
622 * @tc.desc: Normal testCase of RdbPredicates for EqualTo
623 * @tc.type: FUNC
624 */
625 HWTEST_F(RdbStorePredicateTest, RdbStore_EqualTo_001, TestSize.Level1)
626 {
627 RdbPredicates predicates1("AllDataType");
628
629 BasicDataTypeTest(predicates1);
630
631 CalendarTest(predicates1);
632 }
633
634 /* *
635 * @tc.name: RdbStore_EqualTo_002
636 * @tc.desc: Normal testCase of RdbPredicates for EqualTo
637 * @tc.type: FUNC
638 */
639 HWTEST_F(RdbStorePredicateTest, RdbStore_EqualTo_002, TestSize.Level1)
640 {
641 ValuesBucket values;
642 int64_t id;
643 values.PutInt("id", 1);
644 values.PutString("name", std::string("zhangsi"));
645 values.PutInt("age", 18);
646 values.PutInt("REAL", 100);
647 int ret = store->Insert(id, "person", values);
648 EXPECT_EQ(ret, E_OK);
649 EXPECT_EQ(1, id);
650
651 values.Clear();
652 values.PutInt("id", 2);
653 values.PutString("name", std::string("zhangsi"));
654 values.PutInt("age", 18);
655 values.PutInt("REAL", 100);
656 ret = store->Insert(id, "person", values);
657 EXPECT_EQ(ret, E_OK);
658 EXPECT_EQ(2, id);
659
660 RdbPredicates predicates("person");
661 predicates.EqualTo("name", "");
662 std::vector<std::string> columns;
663 std::shared_ptr<ResultSet> allPerson = RdbStorePredicateTest::store->Query(predicates, columns);
664 EXPECT_EQ(0, ResultSize(allPerson));
665
666 RdbPredicates predicates1("person");
667 predicates1.EqualTo("name", "zhangsi");
668 allPerson = RdbStorePredicateTest::store->Query(predicates1, columns);
669 EXPECT_EQ(2, ResultSize(allPerson));
670 RdbStorePredicateTest::store->ExecuteSql("delete from person where id < 3;");
671 }
672
673 /* *
674 * @tc.name: RdbStore_EqualTo_003
675 * @tc.desc: Normal testCase of RdbPredicates for EqualTo
676 * @tc.type: FUNC
677 * @tc.require:
678 */
679 HWTEST_F(RdbStorePredicateTest, RdbStore_EqualTo_003, TestSize.Level1)
680 {
681 ValuesBucket values;
682 int64_t id;
683 values.PutInt("id", 1);
684 std::vector<OHOS::NativeRdb::AssetValue> assets;
685 OHOS::NativeRdb::AssetValue asset{ .name = "asset" };
686 assets.push_back(std::move(asset));
687 ValueObject object(assets);
688 values.Put("attachments", object);
689 int ret = store->Insert(id, "person", values);
690 EXPECT_EQ(ret, E_OK);
691 EXPECT_EQ(1, id);
692
693 RdbPredicates predicates("person");
694 predicates.EqualTo("attachments", object);
695
696 if (predicates.predicates_.operations_.size() != 0) {
697 EXPECT_EQ(
698 predicates.predicates_.operations_[0].operator_, OHOS::DistributedRdb::RdbPredicateOperator::ASSETS_ONLY);
699 } else {
700 EXPECT_TRUE(false);
701 }
702 RdbStorePredicateTest::store->ExecuteSql("delete from person where id < 2;");
703 }
704
705 /* *
706 * @tc.name: RdbStore_EqualTo_004
707 * @tc.desc: Normal testCase of RdbPredicates for EqualTo
708 * @tc.type: FUNC
709 * @tc.require:
710 */
711 HWTEST_F(RdbStorePredicateTest, RdbStore_EqualTo_004, TestSize.Level1)
712 {
713 ValuesBucket values;
714 int64_t id;
715 values.PutInt("id", 1);;
716 OHOS::NativeRdb::AssetValue asset{ .name = "asset" };
717 ValueObject object(asset);
718 values.Put("attachment", object);
719 int ret = store->Insert(id, "person", values);
720 EXPECT_EQ(ret, E_OK);
721 EXPECT_EQ(1, id);
722
723 RdbPredicates predicates("person");
724 predicates.EqualTo("attachment", object);
725 if (predicates.predicates_.operations_.size() != 0) {
726 EXPECT_EQ(
727 predicates.predicates_.operations_[0].operator_, OHOS::DistributedRdb::RdbPredicateOperator::ASSETS_ONLY);
728 } else {
729 EXPECT_TRUE(false);
730 }
731 RdbStorePredicateTest::store->ExecuteSql("delete from person where id < 2;");
732 }
733
CalendarTest(RdbPredicates predicates1)734 void RdbStorePredicateTest::CalendarTest(RdbPredicates predicates1)
735 {
736 std::vector<std::string> columns;
737
738 predicates1.Clear();
739 std::vector<int> date = { 2019, 7, 17 };
740 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
741
742 predicates1.EqualTo("timeValue", std::to_string(calendarTime));
743 std::shared_ptr<ResultSet> allDataTypes9 = RdbStorePredicateTest::store->Query(predicates1, columns);
744 EXPECT_EQ(E_OK, allDataTypes9->GoToFirstRow());
745 int valueInt = 0;
746 allDataTypes9->GetInt(0, valueInt);
747 EXPECT_EQ(2, valueInt);
748 }
749
BasicDataTypeTest(RdbPredicates predicates1)750 void RdbStorePredicateTest::BasicDataTypeTest(RdbPredicates predicates1)
751 {
752 std::vector<std::string> columns;
753 std::stringstream tempValue;
754 predicates1.EqualTo("booleanValue", "1");
755 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
756 EXPECT_EQ(1, ResultSize(allDataTypes1));
757
758 predicates1.Clear();
759 predicates1.EqualTo("byteValue", std::to_string(INT8_MIN))->Or()->EqualTo("byteValue", std::to_string(1));
760 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
761 EXPECT_EQ(2, ResultSize(allDataTypes2));
762
763 predicates1.Clear();
764 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN");
765 std::shared_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
766 EXPECT_EQ(3, ResultSize(allDataTypes3));
767
768 predicates1.Clear();
769 tempValue.str("");
770 tempValue << DBL_MIN;
771 predicates1.EqualTo("doubleValue", tempValue.str());
772 std::shared_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
773 EXPECT_EQ(1, ResultSize(allDataTypes4));
774
775 predicates1.Clear();
776 predicates1.EqualTo("shortValue", std::to_string(SHRT_MIN));
777 std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
778 EXPECT_EQ(1, ResultSize(allDataTypes5));
779
780 predicates1.Clear();
781 predicates1.EqualTo("integerValue", std::to_string(1));
782 std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
783 EXPECT_EQ(E_OK, allDataTypes6->GoToFirstRow());
784 int valueInt = 0;
785 allDataTypes6->GetInt(0, valueInt);
786 EXPECT_EQ(2, valueInt);
787
788 predicates1.Clear();
789 predicates1.EqualTo("longValue", std::to_string(1));
790 std::shared_ptr<ResultSet> allDataTypes7 = RdbStorePredicateTest::store->Query(predicates1, columns);
791 EXPECT_EQ(E_OK, allDataTypes7->GoToFirstRow());
792 allDataTypes7->GetInt(0, valueInt);
793 EXPECT_EQ(2, valueInt);
794
795 predicates1.Clear();
796 tempValue.str("");
797 tempValue << FLT_MIN;
798 predicates1.EqualTo("floatValue", tempValue.str());
799 std::shared_ptr<ResultSet> allDataTypes8 = RdbStorePredicateTest::store->Query(predicates1, columns);
800 EXPECT_EQ(E_OK, allDataTypes8->GoToFirstRow());
801 allDataTypes8->GetInt(0, valueInt);
802 EXPECT_EQ(3, valueInt);
803
804 predicates1.Clear();
805 predicates1.EqualTo("blobValue", std::vector<uint8_t>{ 1, 2, 3 });
806 std::shared_ptr<ResultSet> allDataTypes9 = RdbStorePredicateTest::store->Query(predicates1, columns);
807 // 3 rows in the resultSet when blobValue={1, 2, 3}
808 EXPECT_EQ(3, ResultSize(allDataTypes9));
809 }
810
ResultSize(std::shared_ptr<ResultSet> & resultSet)811 int RdbStorePredicateTest::ResultSize(std::shared_ptr<ResultSet> &resultSet)
812 {
813 if (resultSet->GoToFirstRow() != E_OK) {
814 return 0;
815 }
816 int count = 1;
817 while (resultSet->GoToNextRow() == E_OK) {
818 count++;
819 }
820 return count;
821 }
822
823 /* *
824 * @tc.name: RdbStore_NotEqualTo_001
825 * @tc.desc: Abnormal testCase of RdbPredicates for NotEqualTo, if field is ""
826 * @tc.type: FUNC
827 */
828 HWTEST_F(RdbStorePredicateTest, RdbStore_NotEqualTo_001, TestSize.Level1)
829 {
830 RdbPredicates predicates("AllDataType");
831 predicates.NotEqualTo("", "1");
832
833 std::vector<std::string> columns;
834 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
835 EXPECT_EQ(3, ResultSize(allDataTypes));
836 }
837
838 /* *
839 * @tc.name: RdbStore_NotEqualTo_002
840 * @tc.desc: Normal testCase of RdbPredicates for NotEqualTo
841 * @tc.type: FUNC
842 */
843 HWTEST_F(RdbStorePredicateTest, RdbStore_NotEqualTo_002, TestSize.Level1)
844 {
845 RdbPredicates predicates1("AllDataType");
846
847 BasicDataTypeTest002(predicates1);
848
849 CalendarTest002(predicates1);
850 }
851
852 /* *
853 * @tc.name: RdbStore_NotEqualTo_003
854 * @tc.desc: Normal testCase of RdbPredicates for EqualTo
855 * @tc.type: FUNC
856 */
857 HWTEST_F(RdbStorePredicateTest, RdbStore_NotEqualTo_003, TestSize.Level1)
858 {
859 ValuesBucket values;
860 int64_t id;
861 values.PutInt("id", 1);
862 values.PutString("name", std::string("zhangsi"));
863 values.PutInt("age", 18);
864 values.PutInt("REAL", 100);
865 int ret = store->Insert(id, "person", values);
866 EXPECT_EQ(ret, E_OK);
867 EXPECT_EQ(1, id);
868
869 values.Clear();
870 values.PutInt("id", 2);
871 values.PutString("name", std::string("zhangsi"));
872 values.PutInt("age", 18);
873 values.PutInt("REAL", 100);
874 ret = store->Insert(id, "person", values);
875 EXPECT_EQ(ret, E_OK);
876 EXPECT_EQ(2, id);
877
878 values.Clear();
879 values.PutInt("id", 3);
880 values.PutString("name", std::string(""));
881 values.PutInt("age", 18);
882 values.PutInt("REAL", 100);
883 ret = store->Insert(id, "person", values);
884 EXPECT_EQ(ret, E_OK);
885 EXPECT_EQ(3, id);
886
887 RdbPredicates predicates("person");
888 predicates.NotEqualTo("name", "");
889 std::vector<std::string> columns;
890 std::shared_ptr<ResultSet> allPerson = RdbStorePredicateTest::store->Query(predicates, columns);
891 EXPECT_EQ(2, ResultSize(allPerson));
892
893 RdbPredicates predicates1("person");
894 predicates1.NotEqualTo("name", "zhangsi");
895
896 allPerson = RdbStorePredicateTest::store->Query(predicates1, columns);
897 EXPECT_EQ(1, ResultSize(allPerson));
898
899 RdbStorePredicateTest::store->ExecuteSql("delete from person where id < 4;");
900 }
901
CalendarTest002(RdbPredicates predicates1)902 void RdbStorePredicateTest::CalendarTest002(RdbPredicates predicates1)
903 {
904 std::vector<std::string> columns;
905
906 predicates1.Clear();
907 std::vector<int> date = { 2019, 7, 17 };
908 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
909
910 predicates1.NotEqualTo("timeValue", std::to_string(calendarTime));
911 std::shared_ptr<ResultSet> allDataTypes9 = RdbStorePredicateTest::store->Query(predicates1, columns);
912 EXPECT_EQ(2, ResultSize(allDataTypes9));
913 }
914
BasicDataTypeTest002(RdbPredicates predicates1)915 void RdbStorePredicateTest::BasicDataTypeTest002(RdbPredicates predicates1)
916 {
917 std::vector<std::string> columns;
918 std::stringstream tempValue;
919
920 predicates1.NotEqualTo("primBooleanValue", "1");
921 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
922 EXPECT_EQ(2, ResultSize(allDataTypes1));
923
924 predicates1.Clear();
925 predicates1.NotEqualTo("primByteValue", std::to_string(INT8_MIN))->NotEqualTo("primByteValue", std::to_string(1));
926 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
927 EXPECT_EQ(1, ResultSize(allDataTypes2));
928
929 predicates1.Clear();
930 predicates1.NotEqualTo("stringValue", "ABCDEFGHIJKLMN");
931 std::shared_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
932 EXPECT_EQ(0, ResultSize(allDataTypes3));
933
934 predicates1.Clear();
935 tempValue.str("");
936 tempValue << DBL_MIN;
937 predicates1.NotEqualTo("doubleValue", tempValue.str());
938 std::shared_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
939 EXPECT_EQ(2, ResultSize(allDataTypes4));
940
941 predicates1.Clear();
942 predicates1.NotEqualTo("shortValue", std::to_string(SHRT_MIN));
943 std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
944 EXPECT_EQ(2, ResultSize(allDataTypes5));
945
946 predicates1.Clear();
947 predicates1.NotEqualTo("integerValue", "1");
948 std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
949 EXPECT_EQ(2, ResultSize(allDataTypes6));
950
951 predicates1.Clear();
952 predicates1.NotEqualTo("longValue", "1");
953 std::shared_ptr<ResultSet> allDataTypes7 = RdbStorePredicateTest::store->Query(predicates1, columns);
954 EXPECT_EQ(2, ResultSize(allDataTypes7));
955
956 predicates1.Clear();
957 tempValue.str("");
958 tempValue << FLT_MIN;
959 predicates1.NotEqualTo("floatValue", tempValue.str());
960 std::shared_ptr<ResultSet> allDataTypes8 = RdbStorePredicateTest::store->Query(predicates1, columns);
961 EXPECT_EQ(2, ResultSize(allDataTypes8));
962 }
963
964 /* *
965 * @tc.name: RdbStore_IsNull_003
966 * @tc.desc: Normal testCase of RdbPredicates for IsNull
967 * @tc.type: FUNC
968 */
969 HWTEST_F(RdbStorePredicateTest, RdbStore_IsNull_003, TestSize.Level1)
970 {
971 RdbPredicates predicates1("AllDataType");
972 predicates1.IsNull("primLongValue");
973 std::vector<std::string> columns;
974 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
975 EXPECT_EQ(0, ResultSize(allDataTypes1));
976 }
977
978 /* *
979 * @tc.name: RdbStore_NotNull_004
980 * @tc.desc: Normal testCase of RdbPredicates for NotNull
981 * @tc.type: FUNC
982 */
983 HWTEST_F(RdbStorePredicateTest, RdbStore_NotNull_003, TestSize.Level1)
984 {
985 RdbPredicates predicates1("AllDataType");
986 predicates1.IsNotNull("primLongValue");
987 std::vector<std::string> columns;
988 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
989 EXPECT_EQ(3, ResultSize(allDataTypes1));
990 }
991
992 /* *
993 * @tc.name: RdbStore_GreaterThan_005
994 * @tc.desc: Normal testCase of RdbPredicates for GreaterThan
995 * @tc.type: FUNC
996 */
997 HWTEST_F(RdbStorePredicateTest, RdbStore_GreaterThan_005, TestSize.Level1)
998 {
999 RdbPredicates predicates1("AllDataType");
1000 std::vector<std::string> columns;
1001 std::stringstream tempValue;
1002
1003 predicates1.GreaterThan("stringValue", "ABC");
1004 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1005 EXPECT_EQ(3, ResultSize(allDataTypes1));
1006
1007 predicates1.Clear();
1008 tempValue.str("");
1009 tempValue << DBL_MIN;
1010 predicates1.GreaterThan("doubleValue", tempValue.str());
1011 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1012 EXPECT_EQ(2, ResultSize(allDataTypes2));
1013
1014 predicates1.Clear();
1015 predicates1.GreaterThan("integerValue", "1");
1016 std::shared_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
1017 EXPECT_EQ(1, ResultSize(allDataTypes3));
1018
1019 predicates1.Clear();
1020 predicates1.GreaterThan("longValue", "1");
1021 std::shared_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
1022 EXPECT_EQ(1, ResultSize(allDataTypes4));
1023
1024 predicates1.Clear();
1025 tempValue.str("");
1026 tempValue << FLT_MIN;
1027 predicates1.GreaterThan("floatValue", tempValue.str());
1028 std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1029 EXPECT_EQ(2, ResultSize(allDataTypes5));
1030
1031 predicates1.Clear();
1032 std::vector<int> date = { 2019, 6, 9 };
1033 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
1034 predicates1.GreaterThan("timeValue", std::to_string(calendarTime).c_str());
1035 std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1036 EXPECT_EQ(3, ResultSize(allDataTypes6));
1037 }
1038
1039 /* *
1040 * @tc.name: RdbStore_GreaterThanOrEqualTo_006
1041 * @tc.desc: Normal testCase of RdbPredicates for GreaterThanOrEqualTo
1042 * @tc.type: FUNC
1043 */
1044 HWTEST_F(RdbStorePredicateTest, RdbStore_GreaterThanOrEqualTo_006, TestSize.Level1)
1045 {
1046 RdbPredicates predicates1("AllDataType");
1047 std::vector<std::string> columns;
1048 std::stringstream tempValue;
1049
1050 predicates1.GreaterThanOrEqualTo("stringValue", "ABC");
1051 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1052 EXPECT_EQ(3, ResultSize(allDataTypes1));
1053
1054 predicates1.Clear();
1055 tempValue.str("");
1056 tempValue << DBL_MIN;
1057 predicates1.GreaterThanOrEqualTo("doubleValue", tempValue.str());
1058 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1059 EXPECT_EQ(3, ResultSize(allDataTypes2));
1060
1061 predicates1.Clear();
1062 predicates1.GreaterThanOrEqualTo("integerValue", "1");
1063 std::shared_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
1064 EXPECT_EQ(2, ResultSize(allDataTypes3));
1065
1066 predicates1.Clear();
1067 predicates1.GreaterThanOrEqualTo("longValue", "1");
1068 std::shared_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
1069 EXPECT_EQ(2, ResultSize(allDataTypes4));
1070
1071 predicates1.Clear();
1072 tempValue.str("");
1073 tempValue << FLT_MIN;
1074 predicates1.GreaterThanOrEqualTo("floatValue", tempValue.str());
1075 std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1076 EXPECT_EQ(3, ResultSize(allDataTypes5));
1077
1078 predicates1.Clear();
1079 std::vector<int> date = { 2019, 6, 9 };
1080 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
1081 predicates1.GreaterThanOrEqualTo("timeValue", std::to_string(calendarTime).c_str());
1082 std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1083 EXPECT_EQ(3, ResultSize(allDataTypes6));
1084
1085 // Abnormal testCase of RdbPredicates for GreaterThanOrEqualTo if field is empty
1086 predicates1.Clear();
1087 predicates1.GreaterThanOrEqualTo("", "1");
1088 std::shared_ptr<ResultSet> allDataTypes7 = RdbStorePredicateTest::store->Query(predicates1, columns);
1089 EXPECT_EQ(3, ResultSize(allDataTypes7));
1090 }
1091
1092 /* *
1093 * @tc.name: RdbStore_lessThan_007
1094 * @tc.desc: Normal testCase of RdbPredicates for LessThan
1095 * @tc.type: FUNC
1096 */
1097 HWTEST_F(RdbStorePredicateTest, RdbStore_lessThan_007, TestSize.Level1)
1098 {
1099 RdbPredicates predicates1("AllDataType");
1100 std::vector<std::string> columns;
1101 std::stringstream tempValue;
1102
1103 predicates1.LessThan("stringValue", "ABD");
1104 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1105 EXPECT_EQ(3, ResultSize(allDataTypes1));
1106
1107 predicates1.Clear();
1108 tempValue.str("");
1109 tempValue << DBL_MIN;
1110 predicates1.LessThan("doubleValue", tempValue.str());
1111 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1112 EXPECT_EQ(0, ResultSize(allDataTypes2));
1113
1114 predicates1.Clear();
1115 predicates1.LessThan("integerValue", "1");
1116 std::shared_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
1117 EXPECT_EQ(1, ResultSize(allDataTypes3));
1118
1119 predicates1.Clear();
1120 predicates1.LessThan("longValue", "1");
1121 std::shared_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
1122 EXPECT_EQ(1, ResultSize(allDataTypes4));
1123
1124 predicates1.Clear();
1125 tempValue.str("");
1126 tempValue << FLT_MIN;
1127 predicates1.LessThan("floatValue", tempValue.str());
1128 std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1129 EXPECT_EQ(0, ResultSize(allDataTypes5));
1130
1131 predicates1.Clear();
1132 std::vector<int> date = { 2019, 6, 9 };
1133 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
1134 predicates1.LessThan("timeValue", std::to_string(calendarTime).c_str());
1135 std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1136 EXPECT_EQ(0, ResultSize(allDataTypes6));
1137 }
1138
1139 /* *
1140 * @tc.name: RdbStore_LessThanOrEqualTo_008
1141 * @tc.desc: Normal testCase of RdbPredicates for LessThanOrEqualTo
1142 * @tc.type: FUNC
1143 */
1144 HWTEST_F(RdbStorePredicateTest, RdbStore_LessThanOrEqualTo_008, TestSize.Level1)
1145 {
1146 RdbPredicates predicates1("AllDataType");
1147 std::vector<std::string> columns;
1148 std::stringstream tempValue;
1149
1150 predicates1.LessThanOrEqualTo("stringValue", "ABD");
1151 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1152 EXPECT_EQ(3, ResultSize(allDataTypes1));
1153
1154 predicates1.Clear();
1155 tempValue.str("");
1156 tempValue << DBL_MIN;
1157 predicates1.LessThanOrEqualTo("doubleValue", tempValue.str());
1158 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1159 EXPECT_EQ(1, ResultSize(allDataTypes2));
1160
1161 predicates1.Clear();
1162 predicates1.LessThanOrEqualTo("integerValue", "1");
1163 std::shared_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
1164 EXPECT_EQ(2, ResultSize(allDataTypes3));
1165
1166 predicates1.Clear();
1167 predicates1.LessThanOrEqualTo("longValue", "1");
1168 std::shared_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
1169 EXPECT_EQ(2, ResultSize(allDataTypes4));
1170
1171 predicates1.Clear();
1172 tempValue.str("");
1173 tempValue << FLT_MIN;
1174 predicates1.LessThanOrEqualTo("floatValue", tempValue.str());
1175 std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1176 EXPECT_EQ(1, ResultSize(allDataTypes5));
1177
1178 predicates1.Clear();
1179 std::vector<int> date = { 2019, 6, 9 };
1180 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
1181 predicates1.LessThanOrEqualTo("timeValue", std::to_string(calendarTime).c_str());
1182 std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1183 EXPECT_EQ(0, ResultSize(allDataTypes6));
1184 }
1185
1186 /* *
1187 * @tc.name: RdbStore_Between_009
1188 * @tc.desc: Normal testCase of RdbPredicates for Between
1189 * @tc.type: FUNC
1190 */
1191 HWTEST_F(RdbStorePredicateTest, RdbStore_Between_009, TestSize.Level1)
1192 {
1193 RdbPredicates predicates1("AllDataType");
1194 std::vector<std::string> columns;
1195 std::stringstream tempValue;
1196
1197 predicates1.Between("stringValue", "ABB", "ABD");
1198 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1199 EXPECT_EQ(3, ResultSize(allDataTypes1));
1200
1201 predicates1.Clear();
1202 tempValue.str("");
1203 tempValue << DBL_MAX;
1204 predicates1.Between("doubleValue", "0.0", tempValue.str());
1205 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1206 EXPECT_EQ(3, ResultSize(allDataTypes2));
1207
1208 predicates1.Clear();
1209 predicates1.Between("integerValue", "0", "1");
1210 std::shared_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
1211 EXPECT_EQ(1, ResultSize(allDataTypes3));
1212
1213 predicates1.Clear();
1214 predicates1.Between("longValue", "0", "2");
1215 std::shared_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
1216 EXPECT_EQ(1, ResultSize(allDataTypes4));
1217
1218 predicates1.Clear();
1219 tempValue.str("");
1220 tempValue << FLT_MAX;
1221 std::string floatMax = tempValue.str();
1222 tempValue.str("");
1223 tempValue << FLT_MIN;
1224 predicates1.Between("floatValue", tempValue.str(), floatMax);
1225 std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1226 EXPECT_EQ(3, ResultSize(allDataTypes5));
1227
1228 predicates1.Clear();
1229 std::vector<int> lowCalendar = { 2019, 6, 9 };
1230 time_t lowCalendarTime = RdbStorePredicateTest::DateMakeTime(lowCalendar);
1231 std::vector<int> highCalendar = { 2019, 7, 17 };
1232 time_t highCalendarTime = RdbStorePredicateTest::DateMakeTime(highCalendar);
1233 predicates1.Between("timeValue", std::to_string(lowCalendarTime).c_str(), std::to_string(highCalendarTime).c_str());
1234 std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1235 EXPECT_EQ(3, ResultSize(allDataTypes6));
1236 }
1237
1238 /* *
1239 * @tc.name: RdbStore_Contain_010
1240 * @tc.desc: Normal testCase of RdbPredicates for Contain
1241 * @tc.type: FUNC
1242 */
1243 HWTEST_F(RdbStorePredicateTest, RdbStore_Contain_010, TestSize.Level1)
1244 {
1245 RdbPredicates predicates1("AllDataType");
1246 std::vector<std::string> columns;
1247
1248 predicates1.Contains("stringValue", "DEF");
1249 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1250 EXPECT_EQ(3, ResultSize(allDataTypes1));
1251 }
1252
1253 /* *
1254 * @tc.name: RdbStore_BeginsWith_011
1255 * @tc.desc: Normal testCase of RdbPredicates for BeginsWith
1256 * @tc.type: FUNC
1257 */
1258 HWTEST_F(RdbStorePredicateTest, RdbStore_BeginsWith_011, TestSize.Level1)
1259 {
1260 RdbPredicates predicates1("AllDataType");
1261 std::vector<std::string> columns;
1262
1263 predicates1.BeginsWith("stringValue", "ABC");
1264 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1265 EXPECT_EQ(3, ResultSize(allDataTypes1));
1266 }
1267
1268 /* *
1269 * @tc.name: RdbStore_EndsWith_012
1270 * @tc.desc: Normal testCase of RdbPredicates for EndsWith
1271 * @tc.type: FUNC
1272 */
1273 HWTEST_F(RdbStorePredicateTest, RdbStore_EndsWith_012, TestSize.Level1)
1274 {
1275 RdbPredicates predicates1("AllDataType");
1276 std::vector<std::string> columns;
1277
1278 predicates1.EndsWith("stringValue", "LMN");
1279 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1280 EXPECT_EQ(3, ResultSize(allDataTypes1));
1281 }
1282
1283 /* *
1284 * @tc.name: RdbStore_Like_013
1285 * @tc.desc: Normal testCase of RdbPredicates for Like
1286 * @tc.type: FUNC
1287 */
1288 HWTEST_F(RdbStorePredicateTest, RdbStore_Like_013, TestSize.Level1)
1289 {
1290 RdbPredicates predicates1("AllDataType");
1291 std::vector<std::string> columns;
1292
1293 predicates1.Like("stringValue", "%LMN%");
1294 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1295 EXPECT_EQ(3, ResultSize(allDataTypes1));
1296 }
1297
1298 /* *
1299 * @tc.name: RdbStore_BeginEndWrap_014
1300 * @tc.desc: Normal testCase of RdbPredicates for BeginEndWrap
1301 * @tc.type: FUNC
1302 */
1303 HWTEST_F(RdbStorePredicateTest, RdbStore_BeginEndWrap_014, TestSize.Level1)
1304 {
1305 RdbPredicates predicates1("AllDataType");
1306 std::vector<std::string> columns;
1307
1308 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1309 ->BeginWrap()
1310 ->EqualTo("integerValue", "1")
1311 ->Or()
1312 ->EqualTo("integerValue", std::to_string(INT_MAX))
1313 ->EndWrap();
1314 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1315 EXPECT_EQ(2, ResultSize(allDataTypes1));
1316
1317 predicates1.Clear();
1318 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->And()->EqualTo("integerValue", "1");
1319 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1320 EXPECT_EQ(1, ResultSize(allDataTypes2));
1321 }
1322
1323 /* *
1324 * @tc.name: RdbStore_AndOR_015
1325 * @tc.desc: Normal testCase of RdbPredicates for AndOR
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(RdbStorePredicateTest, RdbStore_AndOR_015, TestSize.Level1)
1329 {
1330 RdbPredicates predicates1("AllDataType");
1331 std::vector<std::string> columns;
1332
1333 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1334 ->BeginWrap()
1335 ->EqualTo("integerValue", "1")
1336 ->Or()
1337 ->EqualTo("integerValue", std::to_string(INT_MAX))
1338 ->EndWrap();
1339
1340 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1341 EXPECT_EQ(2, ResultSize(allDataTypes1));
1342
1343 predicates1.Clear();
1344 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->And()->EqualTo("integerValue", "1");
1345 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1346 EXPECT_EQ(1, ResultSize(allDataTypes2));
1347 }
1348
1349 /* *
1350 * @tc.name: RdbStore_Order_016
1351 * @tc.desc: Normal testCase of RdbPredicates for Order
1352 * @tc.type: FUNC
1353 */
1354 HWTEST_F(RdbStorePredicateTest, RdbStore_Order_016, TestSize.Level1)
1355 {
1356 RdbPredicates predicates1("AllDataType");
1357 std::vector<std::string> columns;
1358
1359 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->OrderByAsc("integerValue")->Distinct();
1360 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1361 EXPECT_EQ(E_OK, allDataTypes1->GoToFirstRow());
1362 int valueInt = 0;
1363 allDataTypes1->GetInt(0, valueInt);
1364 EXPECT_EQ(3, valueInt);
1365 EXPECT_EQ(E_OK, allDataTypes1->GoToNextRow());
1366 allDataTypes1->GetInt(0, valueInt);
1367 EXPECT_EQ(2, valueInt);
1368 EXPECT_EQ(E_OK, allDataTypes1->GoToNextRow());
1369 allDataTypes1->GetInt(0, valueInt);
1370 EXPECT_EQ(1, valueInt);
1371
1372 predicates1.Clear();
1373 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->OrderByDesc("integerValue")->Distinct();
1374 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1375 EXPECT_EQ(E_OK, allDataTypes2->GoToFirstRow());
1376 allDataTypes2->GetInt(0, valueInt);
1377 EXPECT_EQ(1, valueInt);
1378 EXPECT_EQ(E_OK, allDataTypes2->GoToNextRow());
1379 allDataTypes2->GetInt(0, valueInt);
1380 EXPECT_EQ(2, valueInt);
1381 EXPECT_EQ(E_OK, allDataTypes2->GoToNextRow());
1382 allDataTypes2->GetInt(0, valueInt);
1383 EXPECT_EQ(3, valueInt);
1384 }
1385
1386 /* *
1387 * @tc.name: RdbStore_Limit_017
1388 * @tc.desc: Normal testCase of RdbPredicates for Limit
1389 * @tc.type: FUNC
1390 */
1391 HWTEST_F(RdbStorePredicateTest, RdbStore_Limit_017, TestSize.Level1)
1392 {
1393 RdbPredicates predicates1("AllDataType");
1394 std::vector<std::string> columns;
1395
1396 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->Limit(1);
1397 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1398 EXPECT_EQ(1, ResultSize(allDataTypes1));
1399 }
1400
1401 /* *
1402 * @tc.name: RdbStore_JoinTypes_018
1403 * @tc.desc: Normal testCase of RdbPredicates for JoinTypes
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(RdbStorePredicateTest, RdbStore_JoinTypes_018, TestSize.Level1)
1407 {
1408 RdbPredicates predicates1("AllDataType");
1409 std::vector<std::string> joinEntityNames;
1410
1411 joinEntityNames.push_back("AllDataType");
1412 predicates1.SetJoinTableNames(joinEntityNames);
1413
1414 std::vector<std::string> joinTypes;
1415 joinTypes.push_back("INNER JOIN");
1416 predicates1.SetJoinTypes(joinTypes);
1417
1418 std::vector<std::string> joinConditions;
1419 joinConditions.push_back("ON");
1420 predicates1.SetJoinConditions(joinConditions);
1421 predicates1.SetJoinCount(1);
1422
1423 EXPECT_EQ(joinConditions, predicates1.GetJoinConditions());
1424 EXPECT_EQ(joinEntityNames, predicates1.GetJoinTableNames());
1425 EXPECT_EQ(joinTypes, predicates1.GetJoinTypes());
1426 EXPECT_EQ(1, predicates1.GetJoinCount());
1427 }
1428
1429 /* *
1430 * @tc.name: RdbStore_Glob_019
1431 * @tc.desc: Normal testCase of RdbPredicates for Glob
1432 * @tc.type: FUNC
1433 */
1434 HWTEST_F(RdbStorePredicateTest, RdbStore_Glob_019, TestSize.Level1)
1435 {
1436 RdbPredicates predicates1("AllDataType");
1437 std::vector<std::string> columns;
1438
1439 predicates1.Glob("stringValue", "ABC*");
1440 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1441 EXPECT_EQ(3, ResultSize(allDataTypes1));
1442
1443 predicates1.Clear();
1444 predicates1.Glob("stringValue", "*EFG*");
1445 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1446 EXPECT_EQ(3, ResultSize(allDataTypes2));
1447
1448 predicates1.Clear();
1449 predicates1.Glob("stringValue", "?B*");
1450 std::shared_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
1451 EXPECT_EQ(3, ResultSize(allDataTypes3));
1452
1453 predicates1.Clear();
1454 predicates1.Glob("stringValue", "A????????????N");
1455 std::shared_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
1456 EXPECT_EQ(3, ResultSize(allDataTypes4));
1457
1458 predicates1.Clear();
1459 predicates1.Glob("stringValue", "A?????????????N");
1460 std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1461 EXPECT_EQ(0, ResultSize(allDataTypes5));
1462
1463 predicates1.Clear();
1464 predicates1.Glob("stringValue", "?B*N");
1465 std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1466 EXPECT_EQ(3, ResultSize(allDataTypes6));
1467 }
1468
1469 /* *
1470 * @tc.name: RdbStore_NotBetween_020
1471 * @tc.desc: Normal testCase of RdbPredicates for NotBetween
1472 * @tc.type: FUNC
1473 */
1474 HWTEST_F(RdbStorePredicateTest, RdbStore_NotBetween_020, TestSize.Level1)
1475 {
1476 RdbPredicates predicates1("AllDataType");
1477 std::vector<std::string> columns;
1478 std::stringstream tempValue;
1479
1480 predicates1.NotBetween("stringValue", "ABB", "ABD");
1481 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1482 EXPECT_EQ(0, ResultSize(allDataTypes1));
1483
1484 predicates1.Clear();
1485 tempValue.str("");
1486 tempValue << DBL_MAX;
1487 predicates1.NotBetween("doubleValue", "0.0", tempValue.str());
1488 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1489 EXPECT_EQ(0, ResultSize(allDataTypes2));
1490
1491 predicates1.Clear();
1492 predicates1.NotBetween("integerValue", "0", "1");
1493 std::shared_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
1494 EXPECT_EQ(2, ResultSize(allDataTypes3));
1495
1496 predicates1.Clear();
1497 predicates1.NotBetween("longValue", "0", "2");
1498 std::shared_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
1499 EXPECT_EQ(2, ResultSize(allDataTypes4));
1500
1501 predicates1.Clear();
1502 tempValue.str("");
1503 tempValue << FLT_MAX;
1504 std::string floatMax = tempValue.str();
1505 tempValue.str("");
1506 tempValue << FLT_MIN;
1507 predicates1.NotBetween("floatValue", tempValue.str(), floatMax);
1508 std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1509 EXPECT_EQ(0, ResultSize(allDataTypes5));
1510
1511 std::vector<int> lowCalendar = { 2019, 6, 9 };
1512 time_t lowCalendarTime = RdbStorePredicateTest::DateMakeTime(lowCalendar);
1513 std::vector<int> highCalendar = { 2019, 7, 17 };
1514 time_t highCalendarTime = RdbStorePredicateTest::DateMakeTime(highCalendar);
1515 predicates1.Clear();
1516 predicates1.NotBetween("timeValue", std::to_string(lowCalendarTime), std::to_string(highCalendarTime));
1517 std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1518 EXPECT_EQ(0, ResultSize(allDataTypes6));
1519 }
1520
1521 /* *
1522 * @tc.name: RdbStore_ComplexPredicate_021
1523 * @tc.desc: Normal testCase of RdbPredicates for complex combine sql
1524 * @tc.type: FUNC
1525 */
1526 HWTEST_F(RdbStorePredicateTest, RdbStore_ComplexPredicate_021, TestSize.Level1)
1527 {
1528 RdbPredicates predicates1("AllDataType");
1529 std::vector<std::string> columns;
1530
1531 predicates1.Glob("stringValue", "ABC*")->EqualTo("booleanValue", "1")->NotBetween("longValue", "0", "2");
1532 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1533 EXPECT_EQ(1, ResultSize(allDataTypes1));
1534 }
1535
SetJionList(RdbPredicates & predicates1)1536 void RdbStorePredicateTest::SetJionList(RdbPredicates &predicates1)
1537 {
1538 std::vector<std::string> lists = { "ohos", "bazhahei", "zhaxidelie" };
1539 predicates1.SetJoinTableNames(lists);
1540 predicates1.SetJoinCount(1);
1541 predicates1.SetJoinConditions(lists);
1542 predicates1.SetJoinTypes(lists);
1543 predicates1.SetOrder("ohos");
1544 predicates1.Distinct();
1545 }
1546
1547 /* *
1548 * @tc.name: RdbStore_ClearMethod_022
1549 * @tc.desc: Normal testCase of RdbPredicates for Clear Method
1550 * @tc.type: FUNC
1551 */
1552 HWTEST_F(RdbStorePredicateTest, RdbStore_ClearMethod_022, TestSize.Level1)
1553 {
1554 RdbPredicates predicates1("AllDataType");
1555 std::vector<std::string> columns;
1556
1557 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1558 ->BeginWrap()
1559 ->EqualTo("integerValue", "1")
1560 ->Or()
1561 ->EqualTo("integerValue", std::to_string(INT_MAX))
1562 ->EndWrap()
1563 ->OrderByDesc("integerValue")
1564 ->Limit(2);
1565
1566 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1567 EXPECT_EQ(2, ResultSize(allDataTypes1));
1568
1569 EXPECT_EQ("AllDataType", predicates1.GetTableName());
1570 EXPECT_EQ(2, predicates1.GetLimit());
1571 EXPECT_EQ(true, predicates1.GetWhereClause().find("stringValue") != std::string::npos);
1572
1573 std::vector<std::string> agrs = predicates1.GetWhereArgs();
1574 auto ret = find(agrs.begin(), agrs.end(), "ABCDEFGHIJKLMN");
1575 EXPECT_EQ(true, ret != agrs.end());
1576
1577 SetJionList(predicates1);
1578
1579 agrs = predicates1.GetJoinTableNames();
1580 ret = find(agrs.begin(), agrs.end(), "zhaxidelie");
1581 EXPECT_EQ(true, ret != agrs.end());
1582 EXPECT_EQ(1, predicates1.GetJoinCount());
1583
1584 agrs = predicates1.GetJoinConditions();
1585 ret = find(agrs.begin(), agrs.end(), "zhaxidelie");
1586 EXPECT_EQ(true, ret != agrs.end());
1587
1588 agrs = predicates1.GetJoinTypes();
1589 ret = find(agrs.begin(), agrs.end(), "zhaxidelie");
1590 EXPECT_EQ(true, ret != agrs.end());
1591 EXPECT_EQ(true, predicates1.GetJoinClause().find("ohos") != std::string::npos);
1592 EXPECT_EQ("ohos", predicates1.GetOrder());
1593 EXPECT_EQ(true, predicates1.IsDistinct());
1594
1595 predicates1.Clear();
1596 EXPECT_EQ("AllDataType", predicates1.GetTableName());
1597 EXPECT_EQ(-2147483648, predicates1.GetLimit());
1598 EXPECT_EQ(true, predicates1.GetWhereClause().empty());
1599 EXPECT_EQ(true, predicates1.GetWhereArgs().empty());
1600
1601 EXPECT_EQ(true, predicates1.GetJoinTableNames().empty());
1602 EXPECT_EQ(0, predicates1.GetJoinCount());
1603 EXPECT_EQ(true, predicates1.GetJoinConditions().empty());
1604 EXPECT_EQ(true, predicates1.GetJoinTypes().empty());
1605 EXPECT_EQ("", predicates1.GetJoinClause());
1606 EXPECT_EQ(true, predicates1.GetOrder().empty());
1607 EXPECT_EQ(false, predicates1.IsDistinct());
1608 }
1609
1610 /* *
1611 * @tc.name: RdbStore_InMethod_023
1612 * @tc.desc: Normal testCase of RdbPredicates for in method
1613 * @tc.type: FUNC
1614 */
1615 HWTEST_F(RdbStorePredicateTest, RdbStore_InMethod_023, TestSize.Level1)
1616 {
1617 RdbPredicates rdbPredicates1("AllDataType");
1618 std::vector<std::string> columns;
1619 std::vector<std::string> agrs = { std::to_string(INT_MAX) };
1620 rdbPredicates1.In("integerValue", agrs);
1621 std::shared_ptr<ResultSet> resultSet1 = RdbStorePredicateTest::store->Query(rdbPredicates1, columns);
1622 int count = 0;
1623 resultSet1->GetRowCount(count);
1624 EXPECT_EQ(1, count);
1625
1626 RdbPredicates rdbPredicates2("AllDataType");
1627 agrs[0] = "1";
1628 rdbPredicates2.In("longValue", agrs);
1629 std::shared_ptr<ResultSet> resultSet2 = RdbStorePredicateTest::store->Query(rdbPredicates2, columns);
1630 resultSet2->GetRowCount(count);
1631 EXPECT_EQ(1, count);
1632
1633 RdbPredicates rdbPredicates3("AllDataType");
1634 agrs[0] = "1.0";
1635 rdbPredicates3.In("doubleValue", agrs);
1636 std::shared_ptr<ResultSet> resultSet3 = RdbStorePredicateTest::store->Query(rdbPredicates3, columns);
1637 resultSet3->GetRowCount(count);
1638 EXPECT_EQ(1, count);
1639
1640 RdbPredicates rdbPredicates4("AllDataType");
1641 rdbPredicates4.In("floatValue", agrs);
1642 std::shared_ptr<ResultSet> resultSet4 = RdbStorePredicateTest::store->Query(rdbPredicates4, columns);
1643 resultSet4->GetRowCount(count);
1644 EXPECT_EQ(1, count);
1645
1646 std::vector<int> date = { 2019, 6, 10 };
1647 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
1648 RdbPredicates rdbPredicates5("AllDataType");
1649 agrs[0] = std::to_string(calendarTime);
1650 rdbPredicates5.In("timeValue", agrs);
1651 std::shared_ptr<ResultSet> resultSet5 = RdbStorePredicateTest::store->Query(rdbPredicates5, columns);
1652 resultSet5->GetRowCount(count);
1653 EXPECT_EQ(1, count);
1654 }
1655
1656 /* *
1657 * @tc.name: RdbStore_NotInMethod_023
1658 * @tc.desc: Normal testCase of RdbPredicates for notIn method
1659 * @tc.type: FUNC
1660 */
1661 HWTEST_F(RdbStorePredicateTest, RdbStore_NotInMethod_023, TestSize.Level1)
1662 {
1663 std::vector<std::string> columns;
1664 std::vector<std::string> agrs = { std::to_string(INT_MAX), std::to_string(INT_MIN) };
1665 std::stringstream tempValue;
1666
1667 RdbPredicates rdbPredicates1("AllDataType");
1668 rdbPredicates1.NotIn("integerValue", agrs);
1669 std::shared_ptr<ResultSet> resultSet1 = RdbStorePredicateTest::store->Query(rdbPredicates1, columns);
1670 int count = 0;
1671 resultSet1->GetRowCount(count);
1672 EXPECT_EQ(1, count);
1673
1674 RdbPredicates rdbPredicates2("AllDataType");
1675 agrs[0] = "1";
1676 agrs[1] = std::to_string(LONG_MAX);
1677 rdbPredicates2.NotIn("longValue", agrs);
1678 std::shared_ptr<ResultSet> resultSet2 = RdbStorePredicateTest::store->Query(rdbPredicates2, columns);
1679 resultSet2->GetRowCount(count);
1680 EXPECT_EQ(1, count);
1681
1682 RdbPredicates rdbPredicates3("AllDataType");
1683 tempValue.str("");
1684 tempValue << DBL_MIN;
1685 agrs[0] = "1.0";
1686 agrs[1] = tempValue.str();
1687 rdbPredicates3.NotIn("doubleValue", agrs);
1688 std::shared_ptr<ResultSet> resultSet3 = RdbStorePredicateTest::store->Query(rdbPredicates3, columns);
1689 resultSet3->GetRowCount(count);
1690 EXPECT_EQ(1, count);
1691
1692 RdbPredicates rdbPredicates4("AllDataType");
1693 tempValue.str("");
1694 tempValue << FLT_MAX;
1695 agrs[0] = "1.0";
1696 agrs[1] = tempValue.str();
1697 rdbPredicates4.NotIn("floatValue", agrs);
1698 std::shared_ptr<ResultSet> resultSet4 = RdbStorePredicateTest::store->Query(rdbPredicates4, columns);
1699 resultSet4->GetRowCount(count);
1700 EXPECT_EQ(1, count);
1701 }
1702
1703 /* *
1704 * @tc.name: RdbStore_KeywordMethod_024
1705 * @tc.desc: Normal testCase of RdbPredicates for clear method
1706 * @tc.type: FUNC
1707 */
1708 HWTEST_F(RdbStorePredicateTest, RdbStore_KeywordMethod_024, TestSize.Level1)
1709 {
1710 RdbPredicates predicates1("AllDataType");
1711 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1712 ->BeginWrap()
1713 ->EqualTo("integerValue", "1")
1714 ->Or()
1715 ->EqualTo("integerValue", std::to_string(INT_MAX))
1716 ->EndWrap()
1717 ->OrderByDesc("integerValue")
1718 ->Limit(2);
1719
1720 std::vector<std::string> columns = { "booleanValue", "doubleValue", "orderr" };
1721 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1722 allDataTypes1->GoToFirstRow();
1723 int count = ResultSize(allDataTypes1);
1724 EXPECT_EQ(2, count);
1725
1726 EXPECT_EQ("AllDataType", predicates1.GetTableName());
1727 EXPECT_EQ(2, predicates1.GetLimit());
1728
1729 EXPECT_EQ(true, predicates1.GetWhereClause().find("stringValue") != std::string::npos);
1730 std::vector<std::string> args = predicates1.GetWhereArgs();
1731 auto ret = find(args.begin(), args.end(), "ABCDEFGHIJKLMN");
1732 EXPECT_EQ(true, ret != args.end());
1733
1734 SetJionList(predicates1);
1735
1736 args = predicates1.GetJoinTableNames();
1737 ret = find(args.begin(), args.end(), "zhaxidelie");
1738 EXPECT_EQ(true, ret != args.end());
1739 EXPECT_EQ(1, predicates1.GetJoinCount());
1740
1741 args = predicates1.GetJoinConditions();
1742 ret = find(args.begin(), args.end(), "zhaxidelie");
1743 EXPECT_EQ(true, ret != args.end());
1744
1745 args = predicates1.GetJoinTypes();
1746 ret = find(args.begin(), args.end(), "zhaxidelie");
1747 EXPECT_EQ(true, ret != args.end());
1748 EXPECT_EQ(true, predicates1.GetJoinClause().find("ohos") != std::string::npos);
1749 EXPECT_EQ("ohos", predicates1.GetOrder());
1750 EXPECT_EQ(true, predicates1.IsDistinct());
1751
1752 predicates1.Clear();
1753 EXPECT_EQ("AllDataType", predicates1.GetTableName());
1754 EXPECT_EQ(-2147483648, predicates1.GetLimit());
1755 EXPECT_EQ(true, predicates1.GetWhereClause().empty());
1756 EXPECT_EQ(true, predicates1.GetWhereArgs().empty());
1757
1758 EXPECT_EQ(true, predicates1.GetJoinTableNames().empty());
1759 EXPECT_EQ(0, predicates1.GetJoinCount());
1760 EXPECT_EQ(true, predicates1.GetJoinConditions().empty());
1761 EXPECT_EQ(true, predicates1.GetJoinTypes().empty());
1762 EXPECT_EQ("", predicates1.GetJoinClause());
1763 EXPECT_EQ(true, predicates1.GetOrder().empty());
1764 EXPECT_EQ(false, predicates1.IsDistinct());
1765 }
1766
1767 /* *
1768 * @tc.name: RdbStore_ToString_025
1769 * @tc.desc: Normal testCase of RdbPredicates for clear method
1770 * @tc.type: FUNC
1771 */
1772 HWTEST_F(RdbStorePredicateTest, RdbStore_ToString_025, TestSize.Level1)
1773 {
1774 RdbPredicates predicates1("AllDataType");
1775 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1776 ->BeginWrap()
1777 ->EqualTo("integerValue", "1")
1778 ->Or()
1779 ->EqualTo("integerValue", std::to_string(INT_MAX))
1780 ->EndWrap()
1781 ->OrderByDesc("integerValue")
1782 ->Limit(2);
1783 std::string toString = predicates1.ToString();
1784 std::string result = "TableName = AllDataType, {WhereClause:stringValue = ? AND ( integerValue = ? OR "
1785 "integerValue = ? ) , bindArgs:{ABCDEFGHIJKLMN, 1, 2147483647, }, order:integerValue "
1786 "DESC , group:, index:, limit:2, offset:-2147483648, distinct:0, isNeedAnd:1, isSorted:1}";
1787 EXPECT_EQ(result, toString);
1788 }
1789
1790 /* *
1791 * @tc.name: RdbStore_InDevices_InAllDevices_026
1792 * @tc.desc: Normal testCase of RdbPredicates for InDevices and InAllDevices method
1793 * @tc.type: FUNC
1794 */
1795 HWTEST_F(RdbStorePredicateTest, RdbStore_InDevices_InAllDevices_026, TestSize.Level1)
1796 {
1797 RdbPredicates predicates("AllDataType");
1798 std::vector<std::string> devices;
1799 devices.push_back("7001005458323933328a071dab423800");
1800 devices.push_back("7001005458323933328a268fa2fa3900");
1801 AbsRdbPredicates *absRdbPredicates = predicates.InDevices(devices);
1802 EXPECT_NE(absRdbPredicates, nullptr);
1803 AbsRdbPredicates *absRdbPredicates1 = predicates.InAllDevices();
1804 EXPECT_NE(absRdbPredicates1, nullptr);
1805 EXPECT_EQ(absRdbPredicates, absRdbPredicates1);
1806 }
1807
1808 /* *
1809 * @tc.name: RdbStore_GetDistributedPredicates_027
1810 * @tc.desc: Normal testCase of RdbPredicates for GetDistributedPredicates method
1811 * @tc.type: FUNC
1812 * @tc.require:
1813 */
1814 HWTEST_F(RdbStorePredicateTest, RdbStore_GetDistributedPredicates_027, TestSize.Level1)
1815 {
1816 RdbPredicates predicates("AllDataType");
1817 predicates.EqualTo("stringValue", "ABCDEFGHIJKLMN")->OrderByDesc("integerValue")->Limit(2);
1818 auto distributedRdbPredicates = predicates.GetDistributedPredicates();
1819 EXPECT_EQ(*(distributedRdbPredicates.tables_.begin()), "AllDataType");
1820 EXPECT_EQ(distributedRdbPredicates.operations_.size(), 3UL);
1821 EXPECT_EQ(distributedRdbPredicates.operations_[0].operator_, OHOS::DistributedRdb::EQUAL_TO);
1822 EXPECT_EQ(distributedRdbPredicates.operations_[0].field_, "stringValue");
1823 EXPECT_EQ(distributedRdbPredicates.operations_[0].values_[0], "ABCDEFGHIJKLMN");
1824 }
1825
1826 /* *
1827 * @tc.name: RdbStore_NotInMethod_028
1828 * @tc.desc: Abnormal testCase of RdbPredicates for notIn method
1829 * @tc.type: FUNC
1830 */
1831 HWTEST_F(RdbStorePredicateTest, RdbStore_NotInMethod_028, TestSize.Level1)
1832 {
1833 std::vector<std::string> columns;
1834 std::vector<ValueObject> arg;
1835 int count = 0;
1836
1837 // RdbPredicates field is empty
1838 RdbPredicates rdbPredicates1("AllDataType");
1839 rdbPredicates1.NotIn("", arg);
1840 std::shared_ptr<ResultSet> resultSet1 = RdbStorePredicateTest::store->Query(rdbPredicates1, columns);
1841 resultSet1->GetRowCount(count);
1842 EXPECT_EQ(3, count);
1843 resultSet1->Close();
1844
1845 // RdbPredicates values is empty
1846 RdbPredicates rdbPredicates2("AllDataType");
1847 rdbPredicates2.NotIn("integerValue", arg);
1848 std::shared_ptr<ResultSet> resultSet2 = RdbStorePredicateTest::store->Query(rdbPredicates2, columns);
1849 resultSet2->GetRowCount(count);
1850 EXPECT_EQ(3, count);
1851 resultSet2->Close();
1852 }
1853
1854 /* *
1855 * @tc.name: RdbStore_NotContain_029
1856 * @tc.desc: Normal testCase of RdbPredicates for Not Contain
1857 * @tc.type: FUNC
1858 * @tc.require: #I9EMOO
1859 */
1860 HWTEST_F(RdbStorePredicateTest, RdbStore_NotContain_029, TestSize.Level1)
1861 {
1862 RdbPredicates predicates1("AllDataType");
1863 std::vector<std::string> columns;
1864
1865 predicates1.NotContains("stringValue", "OPQ");
1866 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1867 EXPECT_EQ(3, ResultSize(allDataTypes1));
1868 }
1869
1870 /* *
1871 * @tc.name: RdbStore_NotLike_030
1872 * @tc.desc: Normal testCase of RdbPredicates for Not Like
1873 * @tc.type: FUNC
1874 * @tc.require: #I9EMOO
1875 */
1876 HWTEST_F(RdbStorePredicateTest, RdbStore_NotLike_030, TestSize.Level1)
1877 {
1878 RdbPredicates predicates1("AllDataType");
1879 std::vector<std::string> columns;
1880
1881 predicates1.NotLike("stringValue", "OPQ");
1882 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1883 EXPECT_EQ(3, ResultSize(allDataTypes1));
1884 }
1885
1886 /* *
1887 * @tc.name: RdbStore_EndWrap_001
1888 * @tc.desc: Abnormal testCase of RdbPredicates for EndWrap, fail to add ')'
1889 * @tc.type: FUNC
1890 */
1891 HWTEST_F(RdbStorePredicateTest, RdbStore_EndWrap_001, TestSize.Level1)
1892 {
1893 RdbPredicates predicates("AllDataType");
1894 predicates.NotEqualTo("id", "1")->BeginWrap()->EndWrap();
1895
1896 std::vector<std::string> columns;
1897 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
1898 EXPECT_EQ(0, ResultSize(allDataTypes));
1899 allDataTypes->Close();
1900 }
1901
1902 /* *
1903 * @tc.name: RdbStore_Or_001
1904 * @tc.desc: Abnormal testCase of RdbPredicates for Or, fail to add 'OR'
1905 * @tc.type: FUNC
1906 */
1907 HWTEST_F(RdbStorePredicateTest, RdbStore_Or_001, TestSize.Level1)
1908 {
1909 RdbPredicates predicates("AllDataType");
1910 predicates.EqualTo("id", "1")->BeginWrap()->Or();
1911
1912 std::vector<std::string> columns;
1913 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
1914 EXPECT_EQ(0, ResultSize(allDataTypes));
1915 allDataTypes->Close();
1916 }
1917
1918 /* *
1919 * @tc.name: RdbStore_And_001
1920 * @tc.desc: Abnormal testCase of RdbPredicates for And, fail to add 'AND'
1921 * @tc.type: FUNC
1922 */
1923 HWTEST_F(RdbStorePredicateTest, RdbStore_And_001, TestSize.Level1)
1924 {
1925 RdbPredicates predicates("AllDataType");
1926 predicates.EqualTo("id", "1")->BeginWrap()->And();
1927
1928 std::vector<std::string> columns;
1929 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
1930 EXPECT_EQ(0, ResultSize(allDataTypes));
1931 allDataTypes->Close();
1932 }
1933
1934 /* *
1935 * @tc.name: RdbStore_Contain_001
1936 * @tc.desc: Abnormal testCase of RdbPredicates for Contain, if field is ''
1937 * @tc.type: FUNC
1938 */
1939 HWTEST_F(RdbStorePredicateTest, RdbStore_Contain_001, TestSize.Level1)
1940 {
1941 RdbPredicates predicates("AllDataType");
1942 predicates.Contains("", "1");
1943
1944 std::vector<std::string> columns;
1945 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
1946 EXPECT_EQ(3, ResultSize(allDataTypes));
1947 allDataTypes->Close();
1948 }
1949
1950 /* *
1951 * @tc.name: RdbStore_BeginsWith_001
1952 * @tc.desc: Abnormal testCase of RdbPredicates for BeginsWith, if field is ''
1953 * @tc.type: FUNC
1954 */
1955 HWTEST_F(RdbStorePredicateTest, RdbStore_BeginsWith_001, TestSize.Level1)
1956 {
1957 RdbPredicates predicates("AllDataType");
1958 predicates.BeginsWith("", "s");
1959
1960 std::vector<std::string> columns;
1961 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
1962 EXPECT_EQ(3, ResultSize(allDataTypes));
1963 allDataTypes->Close();
1964 }
1965
1966 /* *
1967 * @tc.name: RdbStore_EndsWith_001
1968 * @tc.desc: Abnormal testCase of RdbPredicates for EndsWith, if field is ''
1969 * @tc.type: FUNC
1970 */
1971 HWTEST_F(RdbStorePredicateTest, RdbStore_EndsWith_001, TestSize.Level1)
1972 {
1973 RdbPredicates predicates("AllDataType");
1974 predicates.EndsWith("", "s");
1975
1976 std::vector<std::string> columns;
1977 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
1978 EXPECT_EQ(3, ResultSize(allDataTypes));
1979 allDataTypes->Close();
1980 }
1981
1982 /* *
1983 * @tc.name: RdbStore_IsNull_001
1984 * @tc.desc: Abnormal testCase of RdbPredicates for IsNull, if field is ''
1985 * @tc.type: FUNC
1986 */
1987 HWTEST_F(RdbStorePredicateTest, RdbStore_IsNull_001, TestSize.Level1)
1988 {
1989 RdbPredicates predicates("AllDataType");
1990 predicates.IsNull("");
1991
1992 std::vector<std::string> columns;
1993 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
1994 EXPECT_EQ(3, ResultSize(allDataTypes));
1995 allDataTypes->Close();
1996 }
1997
1998 /* *
1999 * @tc.name: RdbStore_IsNotNull_001
2000 * @tc.desc: Abnormal testCase of RdbPredicates for IsNotNull, if field is ''
2001 * @tc.type: FUNC
2002 */
2003 HWTEST_F(RdbStorePredicateTest, RdbStore_IsNotNull_001, TestSize.Level1)
2004 {
2005 RdbPredicates predicates("AllDataType");
2006 predicates.IsNotNull("");
2007
2008 std::vector<std::string> columns;
2009 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2010 EXPECT_EQ(3, ResultSize(allDataTypes));
2011 allDataTypes->Close();
2012 }
2013
2014 /* *
2015 * @tc.name: RdbStore_Like_001
2016 * @tc.desc: Abnormal testCase of RdbPredicates for Like, if field is ''
2017 * @tc.type: FUNC
2018 */
2019 HWTEST_F(RdbStorePredicateTest, RdbStore_Like_001, TestSize.Level1)
2020 {
2021 RdbPredicates predicates("AllDataType");
2022 predicates.Like("", "wks");
2023
2024 std::vector<std::string> columns;
2025 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2026 EXPECT_EQ(3, ResultSize(allDataTypes));
2027 allDataTypes->Close();
2028 }
2029
2030 /* *
2031 * @tc.name: RdbStore_Glob_001
2032 * @tc.desc: Abnormal testCase of RdbPredicates for Glob, if field is ''
2033 * @tc.type: FUNC
2034 */
2035 HWTEST_F(RdbStorePredicateTest, RdbStore_Glob_001, TestSize.Level1)
2036 {
2037 RdbPredicates predicates("AllDataType");
2038 predicates.Glob("", "wks");
2039
2040 std::vector<std::string> columns;
2041 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2042 EXPECT_EQ(3, ResultSize(allDataTypes));
2043 allDataTypes->Close();
2044 }
2045
2046 /* *
2047 * @tc.name: RdbStore_Between_001
2048 * @tc.desc: Abnormal testCase of RdbPredicates for Between, if field is ''
2049 * @tc.type: FUNC
2050 */
2051 HWTEST_F(RdbStorePredicateTest, RdbStore_Between_001, TestSize.Level1)
2052 {
2053 RdbPredicates predicates("AllDataType");
2054 predicates.Between("", "1", "4");
2055
2056 std::vector<std::string> columns;
2057 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2058 EXPECT_EQ(3, ResultSize(allDataTypes));
2059 allDataTypes->Close();
2060 }
2061
2062 /* *
2063 * @tc.name: RdbStore_NotBetween_001
2064 * @tc.desc: Abnormal testCase of RdbPredicates for NotBetween, if field is ''
2065 * @tc.type: FUNC
2066 */
2067 HWTEST_F(RdbStorePredicateTest, RdbStore_NotBetween_001, TestSize.Level1)
2068 {
2069 RdbPredicates predicates("AllDataType");
2070 predicates.NotBetween("", "1", "4");
2071
2072 std::vector<std::string> columns;
2073 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2074 EXPECT_EQ(3, ResultSize(allDataTypes));
2075 allDataTypes->Close();
2076 }
2077
2078 /* *
2079 * @tc.name: RdbStore_GreaterThan_001
2080 * @tc.desc: Abnormal testCase of RdbPredicates for GreaterThan, if field is ''
2081 * @tc.type: FUNC
2082 */
2083 HWTEST_F(RdbStorePredicateTest, RdbStore_GreaterThan_001, TestSize.Level1)
2084 {
2085 RdbPredicates predicates("AllDataType");
2086 predicates.GreaterThan("", "1");
2087
2088 std::vector<std::string> columns;
2089 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2090 EXPECT_EQ(3, ResultSize(allDataTypes));
2091 allDataTypes->Close();
2092 }
2093
2094 /* *
2095 * @tc.name: RdbStore_LessThan_001
2096 * @tc.desc: Abnormal testCase of RdbPredicates for LessThan, if field is ''
2097 * @tc.type: FUNC
2098 */
2099 HWTEST_F(RdbStorePredicateTest, RdbStore_LessThan_001, TestSize.Level1)
2100 {
2101 RdbPredicates predicates("AllDataType");
2102 predicates.LessThan("", "4");
2103
2104 std::vector<std::string> columns;
2105 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2106 EXPECT_EQ(3, ResultSize(allDataTypes));
2107 allDataTypes->Close();
2108 }
2109
2110 /* *
2111 * @tc.name: RdbStore_GreaterThanOrEqualTo_001
2112 * @tc.desc: Abnormal testCase of RdbPredicates for GreaterThanOrEqualTo, if field is ''
2113 * @tc.type: FUNC
2114 */
2115 HWTEST_F(RdbStorePredicateTest, RdbStore_GreaterThanOrEqualTo_001, TestSize.Level1)
2116 {
2117 RdbPredicates predicates("AllDataType");
2118 predicates.LessThan("", "1");
2119
2120 std::vector<std::string> columns;
2121 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2122 EXPECT_EQ(3, ResultSize(allDataTypes));
2123 allDataTypes->Close();
2124 }
2125
2126 /* *
2127 * @tc.name: RdbStore_LessThanOrEqualTo_001
2128 * @tc.desc: Abnormal testCase of RdbPredicates for LessThanOrEqualTo, if field is ''
2129 * @tc.type: FUNC
2130 */
2131 HWTEST_F(RdbStorePredicateTest, RdbStore_LessThanOrEqualTo_001, TestSize.Level1)
2132 {
2133 RdbPredicates predicates("AllDataType");
2134 predicates.LessThanOrEqualTo("", "1");
2135
2136 std::vector<std::string> columns;
2137 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2138 EXPECT_EQ(3, ResultSize(allDataTypes));
2139 allDataTypes->Close();
2140 }
2141
2142 /* *
2143 * @tc.name: RdbStore_OrderByDesc_001
2144 * @tc.desc: Abnormal testCase of RdbPredicates for OrderByDesc, if field is ''
2145 * @tc.type: FUNC
2146 */
2147 HWTEST_F(RdbStorePredicateTest, RdbStore_OrderByDesc_001, TestSize.Level1)
2148 {
2149 RdbPredicates predicates("AllDataType");
2150 predicates.OrderByDesc("");
2151
2152 std::vector<std::string> columns;
2153 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2154 EXPECT_EQ(3, ResultSize(allDataTypes));
2155 allDataTypes->Close();
2156 }
2157
2158 /* *
2159 * @tc.name: RdbStore_OrderByDesc_002
2160 * @tc.desc: Normal testCase of RdbPredicates for OrderByDesc
2161 * @tc.type: FUNC
2162 */
2163 HWTEST_F(RdbStorePredicateTest, RdbStore_OrderByDesc_002, TestSize.Level2)
2164 {
2165 RdbPredicates predicates("AllDataType");
2166 predicates.OrderByDesc("id");
2167 predicates.OrderByDesc("integerValue");
2168
2169 std::vector<std::string> columns;
2170 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2171 EXPECT_EQ(3, ResultSize(allDataTypes));
2172 allDataTypes->Close();
2173 }
2174
2175 /* *
2176 * @tc.name: RdbStore_OrderByAsc_001
2177 * @tc.desc: Abnormal testCase of RdbPredicates for OrderByAsc, if field is ''
2178 * @tc.type: FUNC
2179 */
2180 HWTEST_F(RdbStorePredicateTest, RdbStore_OrderByAsc_001, TestSize.Level1)
2181 {
2182 RdbPredicates predicates("AllDataType");
2183 predicates.OrderByAsc("");
2184
2185 std::vector<std::string> columns;
2186 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2187 EXPECT_EQ(3, ResultSize(allDataTypes));
2188 allDataTypes->Close();
2189 }
2190
2191 /* *
2192 * @tc.name: RdbStore_OrderByAsc_002
2193 * @tc.desc: Normal testCase of RdbPredicates for OrderByAsc
2194 * @tc.type: FUNC
2195 */
2196 HWTEST_F(RdbStorePredicateTest, RdbStore_OrderByAsc_002, TestSize.Level2)
2197 {
2198 RdbPredicates predicates("AllDataType");
2199 predicates.OrderByAsc("id");
2200 predicates.OrderByAsc("integerValue");
2201
2202 std::vector<std::string> columns;
2203 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2204 EXPECT_EQ(3, ResultSize(allDataTypes));
2205 allDataTypes->Close();
2206 }
2207
2208 /* *
2209 * @tc.name: RdbStore_Limit_001
2210 * @tc.desc: Abnormal testCase of RdbPredicates for OrderByAsc, if set limit param twice
2211 * @tc.type: FUNC
2212 */
2213 HWTEST_F(RdbStorePredicateTest, RdbStore_Limit_001, TestSize.Level1)
2214 {
2215 RdbPredicates predicates("AllDataType");
2216 predicates.Limit(2)->Limit(2);
2217
2218 std::vector<std::string> columns;
2219 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2220 EXPECT_EQ(2, ResultSize(allDataTypes));
2221 allDataTypes->Close();
2222 }
2223
2224 /* *
2225 * @tc.name: RdbStore_Offset_001
2226 * @tc.desc: Abnormal testCase of RdbPredicates for Offset, if set Offset param twice
2227 * @tc.type: FUNC
2228 */
2229 HWTEST_F(RdbStorePredicateTest, RdbStore_Offset_001, TestSize.Level1)
2230 {
2231 RdbPredicates predicates("AllDataType");
2232 predicates.Limit(2)->Offset(1)->Offset(1);
2233
2234 std::vector<std::string> columns;
2235 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2236 EXPECT_EQ(2, ResultSize(allDataTypes));
2237 allDataTypes->Close();
2238 }
2239
2240 /* *
2241 * @tc.name: RdbStore_Offset_002
2242 * @tc.desc: Abnormal testCase of RdbPredicates for Offset, if Offset param is less than 1
2243 * @tc.type: FUNC
2244 */
2245 HWTEST_F(RdbStorePredicateTest, RdbStore_Offset_002, TestSize.Level1)
2246 {
2247 RdbPredicates predicates1("AllDataType");
2248 predicates1.Limit(2)->Offset(0);
2249
2250 std::vector<std::string> columns1;
2251 std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns1);
2252 EXPECT_EQ(2, ResultSize(allDataTypes1));
2253 allDataTypes1->Close();
2254
2255 RdbPredicates predicates2("AllDataType");
2256 predicates2.Limit(2)->Offset(-1);
2257
2258 std::vector<std::string> columns2;
2259 std::shared_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates2, columns2);
2260 EXPECT_EQ(2, ResultSize(allDataTypes2));
2261 allDataTypes2->Close();
2262 }
2263
2264 /* *
2265 * @tc.name: RdbStore_GroupBy_001
2266 * @tc.desc: Abnormal testCase of RdbPredicates for GroupBy, if field is ''
2267 * @tc.type: FUNC
2268 */
2269 HWTEST_F(RdbStorePredicateTest, RdbStore_GroupBy_001, TestSize.Level1)
2270 {
2271 RdbPredicates predicates("AllDataType");
2272 predicates.GroupBy({});
2273
2274 std::vector<std::string> columns;
2275 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2276 EXPECT_EQ(3, ResultSize(allDataTypes));
2277 allDataTypes->Close();
2278 }
2279
2280 /* *
2281 * @tc.name: RdbStore_GroupBy_002
2282 * @tc.desc: Abnormal testCase of RdbPredicates for GroupBy, if param is invalid
2283 * @tc.type: FUNC
2284 */
2285 HWTEST_F(RdbStorePredicateTest, RdbStore_GroupBy_002, TestSize.Level1)
2286 {
2287 RdbPredicates predicates("AllDataType");
2288 predicates.GroupBy({ "idx" });
2289
2290 std::vector<std::string> columns;
2291 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2292 EXPECT_EQ(0, ResultSize(allDataTypes));
2293 allDataTypes->Close();
2294 }
2295
2296 /* *
2297 * @tc.name: RdbStore_GroupBy_003
2298 * @tc.desc: Abnormal testCase of RdbPredicates for GroupBy, if fields is invalid
2299 * @tc.type: FUNC
2300 */
2301 HWTEST_F(RdbStorePredicateTest, RdbStore_GroupBy_003, TestSize.Level1)
2302 {
2303 RdbPredicates predicates("AllDataType");
2304 predicates.GroupBy({ "" });
2305
2306 std::vector<std::string> columns;
2307 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2308 EXPECT_EQ(3, ResultSize(allDataTypes));
2309 allDataTypes->Close();
2310 }
2311
2312 /* *
2313 * @tc.name: RdbStore_IndexedBy_001
2314 * @tc.desc: Abnormal testCase of RdbPredicates for IndexedBy, if field is ''
2315 * @tc.type: FUNC
2316 */
2317 HWTEST_F(RdbStorePredicateTest, RdbStore_IndexedBy_001, TestSize.Level1)
2318 {
2319 RdbPredicates predicates("AllDataType");
2320 predicates.IndexedBy("");
2321
2322 std::vector<std::string> columns;
2323 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2324 EXPECT_EQ(3, ResultSize(allDataTypes));
2325 allDataTypes->Close();
2326 }
2327
2328 /* *
2329 * @tc.name: RdbStore_IndexedBy_002
2330 * @tc.desc: Normal testCase of RdbPredicates for IndexedBy
2331 * @tc.type: FUNC
2332 */
2333 HWTEST_F(RdbStorePredicateTest, RdbStore_IndexedBy_002, TestSize.Level1)
2334 {
2335 RdbStorePredicateTest::store->ExecuteSql("CREATE INDEX orderr_index ON AllDataType(orderr)");
2336
2337 RdbPredicates predicates("AllDataType");
2338 predicates.IndexedBy("orderr_index");
2339
2340 std::vector<std::string> columns;
2341 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2342 EXPECT_EQ(3, ResultSize(allDataTypes));
2343 allDataTypes->Close();
2344 }
2345
2346 /* *
2347 * @tc.name: RdbStore_In_001
2348 * @tc.desc: Abnormal testCase of RdbPredicates for In, if field is ''
2349 * @tc.type: FUNC
2350 */
2351 HWTEST_F(RdbStorePredicateTest, RdbStore_In_001, TestSize.Level1)
2352 {
2353 RdbPredicates predicates("AllDataType");
2354 predicates.In("", std::vector<std::string>{ "1", "3" });
2355
2356 std::vector<std::string> columns;
2357 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2358 EXPECT_EQ(3, ResultSize(allDataTypes));
2359 allDataTypes->Close();
2360 }
2361
2362 /* *
2363 * @tc.name: RdbStore_In_002
2364 * @tc.desc: Abnormal testCase of RdbPredicates for In, if values is []
2365 * @tc.type: FUNC
2366 */
2367 HWTEST_F(RdbStorePredicateTest, RdbStore_In_002, TestSize.Level1)
2368 {
2369 RdbPredicates predicates("AllDataType");
2370 predicates.In("id", std::vector<std::string>{});
2371
2372 std::vector<std::string> columns;
2373 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2374 EXPECT_EQ(0, ResultSize(allDataTypes));
2375 allDataTypes->Close();
2376 }
2377
2378 /* *
2379 * @tc.name: RdbStore_SetOrder_001
2380 * @tc.desc: Abnormal testCase of RdbPredicates for SetOrder, if order is ''
2381 * @tc.type: FUNC
2382 */
2383 HWTEST_F(RdbStorePredicateTest, RdbStore_SetOrder_001, TestSize.Level1)
2384 {
2385 RdbPredicates predicates("AllDataType");
2386 predicates.SetOrder("");
2387
2388 std::vector<std::string> columns;
2389 std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
2390 EXPECT_EQ(3, ResultSize(allDataTypes));
2391 allDataTypes->Close();
2392 }
2393
2394 /* *
2395 * @tc.name: RdbStore_GetStatement_GetBindArgs_001
2396 * @tc.desc: Normal testCase of RdbPredicates for GetStatement and GetBindArgs method
2397 * @tc.type: FUNC
2398 * @tc.require:
2399 */
2400 HWTEST_F(RdbStorePredicateTest, RdbStore_GetStatement_GetBnidArgs_001, TestSize.Level1)
2401 {
2402 RdbPredicates predicates("AllDataType");
2403 predicates.EqualTo("stringValue", "ABCDEFGHIJKLMN")
2404 ->BeginWrap()
2405 ->EqualTo("integerValue", 1)
2406 ->Or()
2407 ->EqualTo("integerValue", INT_MAX)
2408 ->EndWrap()
2409 ->OrderByDesc("integerValue")
2410 ->Limit(-1, -1);
2411
2412 std::vector<std::string> columns;
2413 int count = 0;
2414 std::shared_ptr<ResultSet> resultSet = RdbStorePredicateTest::store->Query(predicates, columns);
2415 resultSet->GetRowCount(count);
2416 EXPECT_EQ(2, count);
2417
2418 std::string statement = predicates.GetStatement();
2419 std::vector<ValueObject> bindArgs = predicates.GetBindArgs();
2420 EXPECT_EQ(statement, " WHERE stringValue = ? AND ( integerValue = ? OR integerValue = ? ) ORDER BY "
2421 "integerValue DESC LIMIT -1 OFFSET -1");
2422 EXPECT_EQ(bindArgs.size(), 3);
2423 }
2424
2425 /* *
2426 * @tc.name: RdbStore_GetStatement_GetBindArgs_002
2427 * @tc.desc: Normal testCase of RdbPredicates for GetStatement and GetBindArgs method
2428 * @tc.type: FUNC
2429 * @tc.require:
2430 */
2431 HWTEST_F(RdbStorePredicateTest, RdbStore_GetStatement_GetBnidArgs_002, TestSize.Level1)
2432 {
2433 RdbPredicates predicates("AllDataType");
2434 predicates.SetWhereClause("integerValue = 1 and ");
2435 predicates.EqualTo("stringValue", "ABCDEFGHIJKLMN");
2436
2437 std::string statement = predicates.GetStatement();
2438 EXPECT_EQ(statement, " WHERE integerValue = 1 and stringValue = ? ");
2439
2440 std::vector<std::string> columns;
2441 int count = 0;
2442 std::shared_ptr<ResultSet> resultSet = RdbStorePredicateTest::store->Query(predicates, columns);
2443 resultSet->GetRowCount(count);
2444 EXPECT_EQ(1, count);
2445 }
2446
2447 /* *
2448 * @tc.name: RdbStore_GetString_001
2449 * @tc.desc: Normal testCase of RdbPredicates for GetString
2450 * @tc.type: FUNC
2451 */
2452 HWTEST_F(RdbStorePredicateTest, RdbStore_GetString_001, TestSize.Level1)
2453 {
2454 ValuesBucket values;
2455 int64_t id;
2456 values.PutInt("id", 1);
2457 values.PutString("name", std::string(""));
2458 values.PutInt("age", 18);
2459 values.PutInt("REAL", 100);
2460 int ret = store->Insert(id, "person", values);
2461 EXPECT_EQ(ret, E_OK);
2462 EXPECT_EQ(1, id);
2463
2464 int errCode = 0;
2465 int columnIndex = 0;
2466 RdbPredicates predicates("person");
2467 predicates.EqualTo("name", "");
2468 std::vector<std::string> columns;
2469 std::shared_ptr<ResultSet> resultSet = RdbStorePredicateTest::store->Query(predicates, columns);
2470 EXPECT_EQ(1, ResultSize(resultSet));
2471
2472 ret = resultSet->GoToFirstRow();
2473 EXPECT_EQ(E_OK, ret);
2474
2475 std::string name;
2476 errCode = resultSet->GetColumnIndex("name", columnIndex);
2477 EXPECT_EQ(errCode, E_OK);
2478 ret = resultSet->GetString(columnIndex, name);
2479 EXPECT_EQ(E_OK, ret);
2480 EXPECT_EQ(name, "");
2481 resultSet->Close();
2482
2483 store->ExecuteSql("DELETE FROM person");
2484 }
2485
2486 /* *
2487 * @tc.name: RdbStore_GetString_002
2488 * @tc.desc: Normal testCase of RdbPredicates for GetString
2489 * @tc.type: FUNC
2490 */
2491 HWTEST_F(RdbStorePredicateTest, RdbStore_GetString_002, TestSize.Level1)
2492 {
2493 ValuesBucket values;
2494 int64_t id;
2495 values.Clear();
2496 values.PutInt("id", 1);
2497 values.PutString("name", std::string(""));
2498 values.PutInt("age", 18);
2499 values.PutInt("REAL", 100);
2500 int ret = store->Insert(id, "person", values);
2501 EXPECT_EQ(ret, E_OK);
2502 EXPECT_EQ(1, id);
2503
2504 std::shared_ptr<ResultSet> resultSet = RdbStorePredicateTest::store->QueryByStep("SELECT * FROM person");
2505 EXPECT_EQ(1, ResultSize(resultSet));
2506
2507 int errCode = 0;
2508 int columnIndex = 0;
2509 ret = resultSet->GoToFirstRow();
2510 EXPECT_EQ(E_OK, ret);
2511
2512 std::string name;
2513 errCode = resultSet->GetColumnIndex("name", columnIndex);
2514 EXPECT_EQ(errCode, E_OK);
2515 ret = resultSet->GetString(columnIndex, name);
2516 EXPECT_EQ(E_OK, ret);
2517 EXPECT_EQ(name, "");
2518 resultSet->Close();
2519
2520 store->ExecuteSql("DELETE FROM person");
2521 }