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