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