1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <sys/stat.h>
18 #include <sys/types.h>
19 #include <unistd.h>
20 #include <string>
21 #include <vector>
22 #include <sstream>
23 #include <algorithm>
24 #include <ctime>
25
26 #include "common.h"
27 #include "rdb_errno.h"
28 #include "rdb_helper.h"
29 #include "rdb_open_callback.h"
30 #include "rdb_predicates.h"
31
32 using namespace testing::ext;
33 using namespace OHOS::NativeRdb;
34
35 class AllDataType {
36 public:
GetId() const37 int GetId() const
38 {
39 return id;
40 }
41
SetId(int id)42 void SetId(int id)
43 {
44 this->id = id;
45 }
46
GetIntegerValue() const47 int GetIntegerValue() const
48 {
49 return integerValue;
50 }
51
SetIntegerValue(int integerValue)52 void SetIntegerValue(int integerValue)
53 {
54 this->integerValue = integerValue;
55 }
56
GetLongValue() const57 int64_t GetLongValue() const
58 {
59 return longValue;
60 }
61
SetLongValue(int64_t longValue)62 void SetLongValue(int64_t longValue)
63 {
64 this->longValue = longValue;
65 }
66
GetShortValue() const67 short GetShortValue() const
68 {
69 return shortValue;
70 }
71
SetShortValue(short shortValue)72 void SetShortValue(short shortValue)
73 {
74 this->shortValue = shortValue;
75 }
76
GetBooleanValue() const77 bool GetBooleanValue() const
78 {
79 return booleanValue;
80 }
81
SetBooleanValue(bool booleanValue)82 void SetBooleanValue(bool booleanValue)
83 {
84 this->booleanValue = booleanValue;
85 }
86
GetDoubleValue() const87 double GetDoubleValue() const
88 {
89 return doubleValue;
90 }
91
SetDoubleValue(double doubleValue)92 void SetDoubleValue(double doubleValue)
93 {
94 this->doubleValue = doubleValue;
95 }
96
GetFloatValue() const97 float GetFloatValue() const
98 {
99 return floatValue;
100 }
101
SetFloatValue(float floatValue)102 void SetFloatValue(float floatValue)
103 {
104 this->floatValue = floatValue;
105 }
106
GetStringValue() const107 std::string GetStringValue() const
108 {
109 return stringValue;
110 }
111
SetStringValue(std::string stringValue)112 void SetStringValue(std::string stringValue)
113 {
114 this->stringValue = stringValue;
115 }
116
GetBlobValue() const117 std::vector<uint8_t> GetBlobValue() const
118 {
119 return blobValue;
120 }
121
SetBlobValue(std::vector<uint8_t> blobValue)122 void SetBlobValue(std::vector<uint8_t> blobValue)
123 {
124 this->blobValue = blobValue;
125 }
126
GetClobValue() const127 std::string GetClobValue() const
128 {
129 return clobValue;
130 }
131
SetClobValue(std::string clobValue)132 void SetClobValue(std::string clobValue)
133 {
134 this->clobValue = clobValue;
135 }
136
GetByteValue() const137 int8_t GetByteValue() const
138 {
139 return byteValue;
140 }
141
SetByteValue(int8_t byteValue)142 void SetByteValue(int8_t byteValue)
143 {
144 this->byteValue = byteValue;
145 }
146
GetTimeValue() const147 time_t GetTimeValue() const
148 {
149 return timeValue;
150 }
151
SetTimeValue(time_t timeValue)152 void SetTimeValue(time_t timeValue)
153 {
154 this->timeValue = timeValue;
155 }
156
GetCharacterValue() const157 char GetCharacterValue() const
158 {
159 return characterValue;
160 }
161
SetCharacterValue(char characterValue)162 void SetCharacterValue(char characterValue)
163 {
164 this->characterValue = characterValue;
165 }
166
GetPrimIntValue() const167 int GetPrimIntValue() const
168 {
169 return primIntValue;
170 }
171
SetPrimIntValue(int primIntValue)172 void SetPrimIntValue(int primIntValue)
173 {
174 this->primIntValue = primIntValue;
175 }
176
GetPrimLongValue() const177 int64_t GetPrimLongValue() const
178 {
179 return primLongValue;
180 }
181
SetPrimLongValue(int64_t primLongValue)182 void SetPrimLongValue(int64_t primLongValue)
183 {
184 this->primLongValue = primLongValue;
185 }
186
GetPrimShortValue() const187 short GetPrimShortValue() const
188 {
189 return primShortValue;
190 }
191
SetPrimShortValue(short primShortValue)192 void SetPrimShortValue(short primShortValue)
193 {
194 this->primShortValue = primShortValue;
195 }
196
GetPrimFloatValue() const197 float GetPrimFloatValue() const
198 {
199 return primFloatValue;
200 }
201
SetPrimFloatValue(float primFloatValue)202 void SetPrimFloatValue(float primFloatValue)
203 {
204 this->primFloatValue = primFloatValue;
205 }
206
GetPrimDoubleValue() const207 double GetPrimDoubleValue() const
208 {
209 return primDoubleValue;
210 }
211
SetPrimDoubleValue(double primDoubleValue)212 void SetPrimDoubleValue(double primDoubleValue)
213 {
214 this->primDoubleValue = primDoubleValue;
215 }
216
IsPrimBooleanValue() const217 bool IsPrimBooleanValue() const
218 {
219 return primBooleanValue;
220 }
221
SetPrimBooleanValue(bool primBooleanValue)222 void SetPrimBooleanValue(bool primBooleanValue)
223 {
224 this->primBooleanValue = primBooleanValue;
225 }
226
GetPrimByteValue() const227 int8_t GetPrimByteValue() const
228 {
229 return primByteValue;
230 }
231
SetPrimByteValue(int8_t primByteValue)232 void SetPrimByteValue(int8_t primByteValue)
233 {
234 this->primByteValue = primByteValue;
235 }
236
GetPrimCharValue() const237 char GetPrimCharValue() const
238 {
239 return primCharValue;
240 }
241
SetPrimCharValue(char primCharValue)242 void SetPrimCharValue(char primCharValue)
243 {
244 this->primCharValue = primCharValue;
245 }
246
GetOrder() const247 int GetOrder() const
248 {
249 return order;
250 }
251
SetOrder(int order)252 void SetOrder(int order)
253 {
254 this->order = order;
255 }
256
257 private:
258 int id;
259
260 int integerValue;
261
262 int64_t longValue;
263
264 short shortValue;
265
266 bool booleanValue = false;
267
268 double doubleValue;
269
270 float floatValue;
271
272 std::string stringValue;
273
274 std::vector<uint8_t> blobValue;
275
276 std::string clobValue;
277
278 int8_t byteValue;
279
280 time_t timeValue;
281
282 int primIntValue;
283
284 char characterValue;
285
286 int64_t primLongValue;
287
288 short primShortValue;
289
290 float primFloatValue;
291
292 double primDoubleValue;
293
294 bool primBooleanValue = false;
295
296 int8_t primByteValue;
297
298 char primCharValue;
299
300 int order;
301 };
302
303 class RdbStorePredicateTest : public testing::Test {
304 public:
305 static void SetUpTestCase(void);
306 static void TearDownTestCase(void);
307 void SetUp();
308 void TearDown();
309
310 static const std::string DATABASE_NAME;
311 static std::shared_ptr<RdbStore> store;
312
313 time_t DateMakeTime(std::vector<int> data);
314 void InsertDates(std::vector<AllDataType> dataTypes);
315 AllDataType *BuildAllDataType1();
316 AllDataType *BuildAllDataType2();
317 AllDataType *BuildAllDataType3();
318 void GenerateAllDataTypeTable();
319 void CalendarTest(RdbPredicates predicates1);
320 void BasicDataTypeTest(RdbPredicates predicates1);
321 int ResultSize(std::unique_ptr<ResultSet> &resultSet);
322 void BasicDataTypeTest002(RdbPredicates predicates1);
323 void CalendarTest002(RdbPredicates predicates1);
324 };
325
326 std::shared_ptr<RdbStore> RdbStorePredicateTest::store = nullptr;
327 const std::string RdbStorePredicateTest::DATABASE_NAME = RDB_TEST_PATH + "predicates_test.db";
328 const std::string CREATE_TABLE_ALL_DATA_TYPE_SQL = std::string("CREATE TABLE IF NOT EXISTS AllDataType ") +
329 std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, integerValue INTEGER , longValue INTEGER , ") +
330 std::string("shortValue INTEGER , booleanValue INTEGER , doubleValue REAL , floatValue REAL , ") +
331 std::string("stringValue TEXT , blobValue BLOB , clobValue TEXT , byteValue INTEGER , ") +
332 std::string("timeValue INTEGER , characterValue TEXT , primIntValue INTEGER ,") +
333 std::string("primLongValue INTEGER NOT NULL, primShortValue INTEGER NOT NULL, ") +
334 std::string("primFloatValue REAL NOT NULL, primDoubleValue REAL NOT NULL, ") +
335 std::string("primBooleanValue INTEGER NOT NULL, primByteValue INTEGER NOT NULL, ") +
336 std::string("primCharValue TEXT, `order` INTEGER);");
337
338 const std::string ALL_DATA_TYPE_INSERT_SQL = std::string("INSERT INTO AllDataType (id, integerValue, longValue, ") +
339 std::string("shortValue, booleanValue, doubleValue, floatValue, stringValue, blobValue, ") +
340 std::string("clobValue, byteValue, timeValue, characterValue, primIntValue, primLongValue, ") +
341 std::string("primShortValue, primFloatValue, primDoubleValue, ") +
342 std::string("primBooleanValue, primByteValue, primCharValue, `order`) ") +
343 std::string("VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);");
344
345 class PredicateTestOpenCallback : public RdbOpenCallback {
346 public:
347 int OnCreate(RdbStore &rdbStore) override;
348 int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override;
349 };
350
OnCreate(RdbStore & store)351 int PredicateTestOpenCallback::OnCreate(RdbStore &store)
352 {
353 return E_OK;
354 }
355
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)356 int PredicateTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
357 {
358 return E_OK;
359 }
360
SetUpTestCase()361 void RdbStorePredicateTest::SetUpTestCase()
362 {}
363
TearDownTestCase()364 void RdbStorePredicateTest::TearDownTestCase()
365 {
366 RdbHelper::DeleteRdbStore(RdbStorePredicateTest::DATABASE_NAME);
367 }
368
SetUp()369 void RdbStorePredicateTest::SetUp()
370 {
371 if (access(RdbStorePredicateTest::DATABASE_NAME.c_str(), F_OK) != 0) {
372 remove(RdbStorePredicateTest::DATABASE_NAME.c_str());
373 }
374
375 int errCode = E_OK;
376 RdbStoreConfig config(RdbStorePredicateTest::DATABASE_NAME);
377 PredicateTestOpenCallback helper;
378 RdbStorePredicateTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
379 EXPECT_NE(RdbStorePredicateTest::store, nullptr);
380
381 RdbStorePredicateTest::GenerateAllDataTypeTable();
382 }
383
TearDown(void)384 void RdbStorePredicateTest::TearDown(void) {}
385
GenerateAllDataTypeTable()386 void RdbStorePredicateTest::GenerateAllDataTypeTable()
387 {
388 RdbStorePredicateTest::store->ExecuteSql(CREATE_TABLE_ALL_DATA_TYPE_SQL);
389
390 AllDataType *dataType1 = RdbStorePredicateTest::BuildAllDataType1();
391
392 AllDataType *dataType2 = RdbStorePredicateTest::BuildAllDataType2();
393
394 AllDataType *dataType3 = RdbStorePredicateTest::BuildAllDataType3();
395
396 std::vector<AllDataType> dataTypes;
397 dataTypes.push_back(*dataType1);
398 dataTypes.push_back(*dataType2);
399 dataTypes.push_back(*dataType3);
400 RdbStorePredicateTest::InsertDates(dataTypes);
401
402 delete dataType1;
403 dataType1 = nullptr;
404 delete dataType2;
405 dataType2 = nullptr;
406 delete dataType3;
407 dataType3 = nullptr;
408 }
409
BuildAllDataType1()410 AllDataType *RdbStorePredicateTest::RdbStorePredicateTest::BuildAllDataType1()
411 {
412 std::vector<uint8_t> blob = {1, 2, 3};
413 AllDataType *dataType = new AllDataType();
414 dataType->SetId(1);
415 dataType->SetIntegerValue(INT_MAX);
416 dataType->SetDoubleValue(DBL_MAX);
417 dataType->SetBooleanValue(true);
418 dataType->SetFloatValue(FLT_MAX);
419 dataType->SetLongValue(LONG_MAX);
420 dataType->SetShortValue(SHRT_MAX);
421 dataType->SetCharacterValue(' ');
422 dataType->SetStringValue("ABCDEFGHIJKLMN");
423 dataType->SetBlobValue(blob);
424 dataType->SetClobValue("ABCDEFGHIJKLMN");
425 dataType->SetByteValue(INT8_MAX);
426
427 std::vector<int> date = {2019, 7, 10};
428 time_t timeValue = RdbStorePredicateTest::DateMakeTime(date);
429 dataType->SetTimeValue(timeValue);
430
431 dataType->SetPrimIntValue(INT_MAX);
432 dataType->SetPrimDoubleValue(DBL_MAX);
433 dataType->SetPrimFloatValue(FLT_MAX);
434 dataType->SetPrimBooleanValue(true);
435 dataType->SetPrimByteValue(INT8_MAX);
436 dataType->SetPrimCharValue(' ');
437 dataType->SetPrimLongValue(LONG_MAX);
438 dataType->SetPrimShortValue(SHRT_MAX);
439 return dataType;
440 }
441
BuildAllDataType2()442 AllDataType *RdbStorePredicateTest::BuildAllDataType2()
443 {
444 std::vector<uint8_t> blob = {1, 2, 3};
445 AllDataType *dataType2 = new AllDataType();
446 dataType2->SetId(2);
447 dataType2->SetIntegerValue(1);
448 dataType2->SetDoubleValue(1.0);
449 dataType2->SetBooleanValue(false);
450 dataType2->SetFloatValue(1.0);
451 dataType2->SetLongValue(static_cast<int64_t>(1));
452 dataType2->SetShortValue(static_cast<short>(1));
453 dataType2->SetCharacterValue(' ');
454 dataType2->SetStringValue("ABCDEFGHIJKLMN");
455 dataType2->SetBlobValue(blob);
456 dataType2->SetClobValue("ABCDEFGHIJKLMN");
457 dataType2->SetByteValue(INT8_MIN);
458
459 std::vector<int> date = {2019, 7, 17};
460 time_t timeValue2 = RdbStorePredicateTest::DateMakeTime(date);
461 dataType2->SetTimeValue(timeValue2);
462
463 dataType2->SetPrimIntValue(1);
464 dataType2->SetPrimDoubleValue(1.0);
465 dataType2->SetPrimFloatValue(1.0);
466 dataType2->SetPrimBooleanValue(false);
467 dataType2->SetPrimByteValue(static_cast<char>(1));
468 dataType2->SetPrimCharValue(' ');
469 dataType2->SetPrimLongValue(static_cast<int64_t>(1));
470 dataType2->SetPrimShortValue(static_cast<short>(1));
471 return dataType2;
472 }
473
BuildAllDataType3()474 AllDataType *RdbStorePredicateTest::BuildAllDataType3()
475 {
476 std::vector<uint8_t> blob = {1, 2, 3};
477 AllDataType *dataType3 = new AllDataType();
478 dataType3->SetId(3);
479 dataType3->SetIntegerValue(INT_MIN);
480 dataType3->SetDoubleValue(DBL_MIN);
481 dataType3->SetBooleanValue(false);
482 dataType3->SetFloatValue(FLT_MIN);
483 dataType3->SetLongValue(LONG_MIN);
484 dataType3->SetShortValue(SHRT_MIN);
485 dataType3->SetCharacterValue(' ');
486 dataType3->SetStringValue("ABCDEFGHIJKLMN");
487 dataType3->SetBlobValue(blob);
488 dataType3->SetClobValue("ABCDEFGHIJKLMN");
489 dataType3->SetByteValue(INT8_MIN);
490
491 std::vector<int> date = {2019, 6, 10};
492 time_t timeValue3 = RdbStorePredicateTest::DateMakeTime(date);
493 dataType3->SetTimeValue(timeValue3);
494
495 dataType3->SetPrimIntValue(INT_MIN);
496 dataType3->SetPrimDoubleValue(DBL_MIN);
497 dataType3->SetPrimFloatValue(FLT_MIN);
498 dataType3->SetPrimBooleanValue(false);
499 dataType3->SetPrimByteValue(INT8_MIN);
500 dataType3->SetPrimCharValue(' ');
501 dataType3->SetPrimLongValue(LONG_MIN);
502 dataType3->SetPrimShortValue(SHRT_MIN);
503 return dataType3;
504 }
505
InsertDates(std::vector<AllDataType> dataTypes)506 void RdbStorePredicateTest::InsertDates(std::vector<AllDataType> dataTypes)
507 {
508 for (size_t i = 0; i < dataTypes.size(); i++) {
509 char characterValue = dataTypes[i].GetCharacterValue();
510 char primCharValue = dataTypes[i].GetPrimCharValue();
511 std::stringstream strByte;
512 std::vector<ValueObject> objects;
513 objects.push_back(ValueObject(dataTypes[i].GetId()));
514 objects.push_back(ValueObject(dataTypes[i].GetIntegerValue()));
515 objects.push_back(ValueObject(dataTypes[i].GetLongValue()));
516 objects.push_back(ValueObject(dataTypes[i].GetShortValue()));
517 objects.push_back(ValueObject(dataTypes[i].GetBooleanValue()));
518
519 strByte << dataTypes[i].GetDoubleValue();
520 objects.push_back(ValueObject(strByte.str()));
521
522 strByte.str("");
523 strByte << dataTypes[i].GetFloatValue();
524 objects.push_back(ValueObject(strByte.str()));
525 objects.push_back(ValueObject(dataTypes[i].GetStringValue()));
526 objects.push_back(ValueObject(dataTypes[i].GetBlobValue()));
527 objects.push_back(ValueObject(dataTypes[i].GetClobValue()));
528 objects.push_back(ValueObject(dataTypes[i].GetByteValue()));
529 objects.push_back(ValueObject(static_cast<int64_t>(dataTypes[i].GetTimeValue())));
530
531 strByte.str("");
532 strByte << characterValue;
533 string str1 = strByte.str();
534 objects.push_back(ValueObject(str1));
535 objects.push_back(ValueObject(dataTypes[i].GetPrimIntValue()));
536 objects.push_back(ValueObject(dataTypes[i].GetPrimLongValue()));
537 objects.push_back(ValueObject(dataTypes[i].GetPrimShortValue()));
538
539 strByte.str("");
540 strByte << dataTypes[i].GetPrimFloatValue();
541 objects.push_back(ValueObject(strByte.str()));
542
543 strByte.str("");
544 strByte << dataTypes[i].GetPrimDoubleValue();
545 objects.push_back(ValueObject(strByte.str()));
546 objects.push_back(ValueObject(dataTypes[i].IsPrimBooleanValue() ? (char) 1 : (char) 0));
547 objects.push_back(ValueObject(dataTypes[i].GetPrimByteValue()));
548
549 strByte.str("");
550 strByte << primCharValue;
551 string str2 = strByte.str();
552 objects.push_back(ValueObject(str2));
553 RdbStorePredicateTest::store->ExecuteSql(ALL_DATA_TYPE_INSERT_SQL, objects);
554 }
555 }
556
DateMakeTime(std::vector<int> data)557 time_t RdbStorePredicateTest::DateMakeTime(std::vector<int> data)
558 {
559 struct tm t1 = {0};
560 t1.tm_year = data[0] - 1990;
561 t1.tm_mon = data[1] - 1;
562 t1.tm_hour = data[2];
563 t1.tm_sec = 0;
564 t1.tm_min = 0;
565 t1.tm_mday = 0;
566 time_t time = mktime(&t1);
567 return time;
568 }
569
570 /* *
571 * @tc.name: RdbStore_EqualTo_001
572 * @tc.desc: Normal testCase of RdbPredicates for EqualTo
573 * @tc.type: FUNC
574 * @tc.require: AR000FKD4F
575 */
576 HWTEST_F(RdbStorePredicateTest, RdbStore_EqualTo_001, TestSize.Level1)
577 {
578 RdbPredicates predicates1("AllDataType");
579
580 BasicDataTypeTest(predicates1);
581
582 CalendarTest(predicates1);
583 }
584
CalendarTest(RdbPredicates predicates1)585 void RdbStorePredicateTest::CalendarTest(RdbPredicates predicates1)
586 {
587 std::vector<std::string> columns;
588
589 predicates1.Clear();
590 std::vector<int> date = {2019, 7, 17};
591 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
592
593 predicates1.EqualTo("timeValue", std::to_string(calendarTime));
594 std::unique_ptr<ResultSet> allDataTypes9 = RdbStorePredicateTest::store->Query(predicates1, columns);
595 EXPECT_EQ(E_OK, allDataTypes9->GoToFirstRow());
596 int valueInt = 0;
597 allDataTypes9->GetInt(0, valueInt);
598 EXPECT_EQ(2, valueInt);
599 }
BasicDataTypeTest(RdbPredicates predicates1)600 void RdbStorePredicateTest::BasicDataTypeTest(RdbPredicates predicates1)
601 {
602 std::vector<std::string> columns;
603 std::stringstream tempValue;
604 predicates1.EqualTo("booleanValue", "1");
605 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
606 EXPECT_EQ(1, ResultSize(allDataTypes1));
607
608 predicates1.Clear();
609 predicates1.EqualTo("byteValue", std::to_string(INT8_MIN))->Or()->EqualTo("byteValue", std::to_string(1));
610 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
611 EXPECT_EQ(2, ResultSize(allDataTypes2));
612
613 predicates1.Clear();
614 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN");
615 std::unique_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
616 EXPECT_EQ(3, ResultSize(allDataTypes3));
617
618 predicates1.Clear();
619 tempValue.str("");
620 tempValue << DBL_MIN;
621 predicates1.EqualTo("doubleValue", tempValue.str());
622 std::unique_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
623 EXPECT_EQ(1, ResultSize(allDataTypes4));
624
625 predicates1.Clear();
626 predicates1.EqualTo("shortValue", std::to_string(SHRT_MIN));
627 std::unique_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
628 EXPECT_EQ(1, ResultSize(allDataTypes5));
629
630 predicates1.Clear();
631 predicates1.EqualTo("integerValue", std::to_string(1));
632 std::unique_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
633 EXPECT_EQ(E_OK, allDataTypes6->GoToFirstRow());
634 int valueInt = 0;
635 allDataTypes6->GetInt(0, valueInt);
636 EXPECT_EQ(2, valueInt);
637
638 predicates1.Clear();
639 predicates1.EqualTo("longValue", std::to_string(1));
640 std::unique_ptr<ResultSet> allDataTypes7 = RdbStorePredicateTest::store->Query(predicates1, columns);
641 EXPECT_EQ(E_OK, allDataTypes7->GoToFirstRow());
642 allDataTypes7->GetInt(0, valueInt);
643 EXPECT_EQ(2, valueInt);
644
645 predicates1.Clear();
646 tempValue.str("");
647 tempValue << FLT_MIN;
648 predicates1.EqualTo("floatValue", tempValue.str());
649 std::unique_ptr<ResultSet> allDataTypes8 = RdbStorePredicateTest::store->Query(predicates1, columns);
650 EXPECT_EQ(E_OK, allDataTypes8->GoToFirstRow());
651 allDataTypes8->GetInt(0, valueInt);
652 EXPECT_EQ(3, valueInt);
653 }
654
ResultSize(std::unique_ptr<ResultSet> & resultSet)655 int RdbStorePredicateTest::ResultSize(std::unique_ptr<ResultSet> &resultSet)
656 {
657 if (resultSet->GoToFirstRow() != E_OK) {
658 return 0;
659 }
660 int count = 1;
661 while (resultSet->GoToNextRow() == E_OK) {
662 count++;
663 }
664 return count;
665 }
666
667 /* *
668 * @tc.name: RdbStore_NotEqualTo_002
669 * @tc.desc: Normal testCase of RdbPredicates for NotEqualTo
670 * @tc.type: FUNC
671 * @tc.require: AR000FKD4F
672 */
673 HWTEST_F(RdbStorePredicateTest, RdbStore_NotEqualTo_002, TestSize.Level1)
674 {
675 RdbPredicates predicates1("AllDataType");
676
677 BasicDataTypeTest002(predicates1);
678
679 CalendarTest002(predicates1);
680 }
681
CalendarTest002(RdbPredicates predicates1)682 void RdbStorePredicateTest::CalendarTest002(RdbPredicates predicates1)
683 {
684 std::vector<std::string> columns;
685
686 predicates1.Clear();
687 std::vector<int> date = {2019, 7, 17};
688 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
689
690 predicates1.NotEqualTo("timeValue", std::to_string(calendarTime));
691 std::unique_ptr<ResultSet> allDataTypes9 = RdbStorePredicateTest::store->Query(predicates1, columns);
692 EXPECT_EQ(2, ResultSize(allDataTypes9));
693 }
BasicDataTypeTest002(RdbPredicates predicates1)694 void RdbStorePredicateTest::BasicDataTypeTest002(RdbPredicates predicates1)
695 {
696 std::vector<std::string> columns;
697 std::stringstream tempValue;
698
699 predicates1.NotEqualTo("primBooleanValue", "1");
700 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
701 EXPECT_EQ(2, ResultSize(allDataTypes1));
702
703 predicates1.Clear();
704 predicates1.NotEqualTo("primByteValue", std::to_string(INT8_MIN))->NotEqualTo("primByteValue", std::to_string(1));
705 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
706 EXPECT_EQ(1, ResultSize(allDataTypes2));
707
708 predicates1.Clear();
709 predicates1.NotEqualTo("stringValue", "ABCDEFGHIJKLMN");
710 std::unique_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
711 EXPECT_EQ(0, ResultSize(allDataTypes3));
712
713 predicates1.Clear();
714 tempValue.str("");
715 tempValue << DBL_MIN;
716 predicates1.NotEqualTo("doubleValue", tempValue.str());
717 std::unique_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
718 EXPECT_EQ(2, ResultSize(allDataTypes4));
719
720 predicates1.Clear();
721 predicates1.NotEqualTo("shortValue", std::to_string(SHRT_MIN));
722 std::unique_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
723 EXPECT_EQ(2, ResultSize(allDataTypes5));
724
725 predicates1.Clear();
726 predicates1.NotEqualTo("integerValue", "1");
727 std::unique_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
728 EXPECT_EQ(2, ResultSize(allDataTypes6));
729
730 predicates1.Clear();
731 predicates1.NotEqualTo("longValue", "1");
732 std::unique_ptr<ResultSet> allDataTypes7 = RdbStorePredicateTest::store->Query(predicates1, columns);
733 EXPECT_EQ(2, ResultSize(allDataTypes7));
734
735 predicates1.Clear();
736 tempValue.str("");
737 tempValue << FLT_MIN;
738 predicates1.NotEqualTo("floatValue", tempValue.str());
739 std::unique_ptr<ResultSet> allDataTypes8 = RdbStorePredicateTest::store->Query(predicates1, columns);
740 EXPECT_EQ(2, ResultSize(allDataTypes8));
741 }
742
743 /* *
744 * @tc.name: RdbStore_IsNull_003
745 * @tc.desc: Normal testCase of RdbPredicates for IsNull
746 * @tc.type: FUNC
747 * @tc.require: AR000FKD4F
748 */
749 HWTEST_F(RdbStorePredicateTest, RdbStore_IsNull_003, TestSize.Level1)
750 {
751 RdbPredicates predicates1("AllDataType");
752 predicates1.IsNull("primLongValue");
753 std::vector<std::string> columns;
754 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
755 EXPECT_EQ(0, ResultSize(allDataTypes1));
756 }
757
758 /* *
759 * @tc.name: RdbStore_NotNull_004
760 * @tc.desc: Normal testCase of RdbPredicates for NotNull
761 * @tc.type: FUNC
762 * @tc.require: AR000FKD4F
763 */
764 HWTEST_F(RdbStorePredicateTest, RdbStore_NotNull_003, TestSize.Level1)
765 {
766 RdbPredicates predicates1("AllDataType");
767 predicates1.IsNotNull("primLongValue");
768 std::vector<std::string> columns;
769 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
770 EXPECT_EQ(3, ResultSize(allDataTypes1));
771 }
772
773 /* *
774 * @tc.name: RdbStore_GreaterThan_005
775 * @tc.desc: Normal testCase of RdbPredicates for GreaterThan
776 * @tc.type: FUNC
777 * @tc.require: AR000FKD4F
778 */
779 HWTEST_F(RdbStorePredicateTest, RdbStore_GreaterThan_005, TestSize.Level1)
780 {
781 RdbPredicates predicates1("AllDataType");
782 std::vector<std::string> columns;
783 std::stringstream tempValue;
784
785 predicates1.GreaterThan("stringValue", "ABC");
786 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
787 EXPECT_EQ(3, ResultSize(allDataTypes1));
788
789 predicates1.Clear();
790 tempValue.str("");
791 tempValue << DBL_MIN;
792 predicates1.GreaterThan("doubleValue", tempValue.str());
793 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
794 EXPECT_EQ(2, ResultSize(allDataTypes2));
795
796 predicates1.Clear();
797 predicates1.GreaterThan("integerValue", "1");
798 std::unique_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
799 EXPECT_EQ(1, ResultSize(allDataTypes3));
800
801 predicates1.Clear();
802 predicates1.GreaterThan("longValue", "1");
803 std::unique_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
804 EXPECT_EQ(1, ResultSize(allDataTypes4));
805
806 predicates1.Clear();
807 tempValue.str("");
808 tempValue << FLT_MIN;
809 predicates1.GreaterThan("floatValue", tempValue.str());
810 std::unique_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
811 EXPECT_EQ(2, ResultSize(allDataTypes5));
812
813 predicates1.Clear();
814 std::vector<int> date = {2019, 6, 9};
815 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
816 predicates1.GreaterThan("timeValue", std::to_string(calendarTime).c_str());
817 std::unique_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
818 EXPECT_EQ(3, ResultSize(allDataTypes6));
819 }
820
821 /* *
822 * @tc.name: RdbStore_GreaterThanOrEqualTo_006
823 * @tc.desc: Normal testCase of RdbPredicates for GreaterThanOrEqualTo
824 * @tc.type: FUNC
825 * @tc.require: AR000FKD4F
826 */
827 HWTEST_F(RdbStorePredicateTest, RdbStore_GreaterThanOrEqualTo_006, TestSize.Level1)
828 {
829 RdbPredicates predicates1("AllDataType");
830 std::vector<std::string> columns;
831 std::stringstream tempValue;
832
833 predicates1.GreaterThanOrEqualTo("stringValue", "ABC");
834 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
835 EXPECT_EQ(3, ResultSize(allDataTypes1));
836
837 predicates1.Clear();
838 tempValue.str("");
839 tempValue << DBL_MIN;
840 predicates1.GreaterThanOrEqualTo("doubleValue", tempValue.str());
841 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
842 EXPECT_EQ(3, ResultSize(allDataTypes2));
843
844 predicates1.Clear();
845 predicates1.GreaterThanOrEqualTo("integerValue", "1");
846 std::unique_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
847 EXPECT_EQ(2, ResultSize(allDataTypes3));
848
849 predicates1.Clear();
850 predicates1.GreaterThanOrEqualTo("longValue", "1");
851 std::unique_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
852 EXPECT_EQ(2, ResultSize(allDataTypes4));
853
854 predicates1.Clear();
855 tempValue.str("");
856 tempValue << FLT_MIN;
857 predicates1.GreaterThanOrEqualTo("floatValue", tempValue.str());
858 std::unique_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
859 EXPECT_EQ(3, ResultSize(allDataTypes5));
860
861 predicates1.Clear();
862 std::vector<int> date = {2019, 6, 9};
863 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
864 predicates1.GreaterThanOrEqualTo("timeValue", std::to_string(calendarTime).c_str());
865 std::unique_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
866 EXPECT_EQ(3, ResultSize(allDataTypes6));
867 }
868
869 /* *
870 * @tc.name: RdbStore_lessThan_007
871 * @tc.desc: Normal testCase of RdbPredicates for LessThan
872 * @tc.type: FUNC
873 * @tc.require: AR000FKD4F
874 */
875 HWTEST_F(RdbStorePredicateTest, RdbStore_lessThan_007, TestSize.Level1)
876 {
877 RdbPredicates predicates1("AllDataType");
878 std::vector<std::string> columns;
879 std::stringstream tempValue;
880
881 predicates1.LessThan("stringValue", "ABD");
882 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
883 EXPECT_EQ(3, ResultSize(allDataTypes1));
884
885 predicates1.Clear();
886 tempValue.str("");
887 tempValue << DBL_MIN;
888 predicates1.LessThan("doubleValue", tempValue.str());
889 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
890 EXPECT_EQ(0, ResultSize(allDataTypes2));
891
892 predicates1.Clear();
893 predicates1.LessThan("integerValue", "1");
894 std::unique_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
895 EXPECT_EQ(1, ResultSize(allDataTypes3));
896
897 predicates1.Clear();
898 predicates1.LessThan("longValue", "1");
899 std::unique_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
900 EXPECT_EQ(1, ResultSize(allDataTypes4));
901
902 predicates1.Clear();
903 tempValue.str("");
904 tempValue << FLT_MIN;
905 predicates1.LessThan("floatValue", tempValue.str());
906 std::unique_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
907 EXPECT_EQ(0, ResultSize(allDataTypes5));
908
909 predicates1.Clear();
910 std::vector<int> date = {2019, 6, 9};
911 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
912 predicates1.LessThan("timeValue", std::to_string(calendarTime).c_str());
913 std::unique_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
914 EXPECT_EQ(0, ResultSize(allDataTypes6));
915 }
916
917 /* *
918 * @tc.name: RdbStore_LessThanOrEqualTo_008
919 * @tc.desc: Normal testCase of RdbPredicates for LessThanOrEqualTo
920 * @tc.type: FUNC
921 * @tc.require: AR000FKD4F
922 */
923 HWTEST_F(RdbStorePredicateTest, RdbStore_LessThanOrEqualTo_008, TestSize.Level1)
924 {
925 RdbPredicates predicates1("AllDataType");
926 std::vector<std::string> columns;
927 std::stringstream tempValue;
928
929 predicates1.LessThanOrEqualTo("stringValue", "ABD");
930 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
931 EXPECT_EQ(3, ResultSize(allDataTypes1));
932
933 predicates1.Clear();
934 tempValue.str("");
935 tempValue << DBL_MIN;
936 predicates1.LessThanOrEqualTo("doubleValue", tempValue.str());
937 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
938 EXPECT_EQ(1, ResultSize(allDataTypes2));
939
940 predicates1.Clear();
941 predicates1.LessThanOrEqualTo("integerValue", "1");
942 std::unique_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
943 EXPECT_EQ(2, ResultSize(allDataTypes3));
944
945 predicates1.Clear();
946 predicates1.LessThanOrEqualTo("longValue", "1");
947 std::unique_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
948 EXPECT_EQ(2, ResultSize(allDataTypes4));
949
950 predicates1.Clear();
951 tempValue.str("");
952 tempValue << FLT_MIN;
953 predicates1.LessThanOrEqualTo("floatValue", tempValue.str());
954 std::unique_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
955 EXPECT_EQ(1, ResultSize(allDataTypes5));
956
957 predicates1.Clear();
958 std::vector<int> date = {2019, 6, 9};
959 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
960 predicates1.LessThanOrEqualTo("timeValue", std::to_string(calendarTime).c_str());
961 std::unique_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
962 EXPECT_EQ(0, ResultSize(allDataTypes6));
963 }
964
965 /* *
966 * @tc.name: RdbStore_Between_009
967 * @tc.desc: Normal testCase of RdbPredicates for Between
968 * @tc.type: FUNC
969 * @tc.require: AR000FKD4F
970 */
971 HWTEST_F(RdbStorePredicateTest, RdbStore_Between_009, TestSize.Level1)
972 {
973 RdbPredicates predicates1("AllDataType");
974 std::vector<std::string> columns;
975 std::stringstream tempValue;
976
977 predicates1.Between("stringValue", "ABB", "ABD");
978 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
979 EXPECT_EQ(3, ResultSize(allDataTypes1));
980
981 predicates1.Clear();
982 tempValue.str("");
983 tempValue << DBL_MAX;
984 predicates1.Between("doubleValue", "0.0", tempValue.str());
985 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
986 EXPECT_EQ(3, ResultSize(allDataTypes2));
987
988 predicates1.Clear();
989 predicates1.Between("integerValue", "0", "1");
990 std::unique_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
991 EXPECT_EQ(1, ResultSize(allDataTypes3));
992
993 predicates1.Clear();
994 predicates1.Between("longValue", "0", "2");
995 std::unique_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
996 EXPECT_EQ(1, ResultSize(allDataTypes4));
997
998 predicates1.Clear();
999 tempValue.str("");
1000 tempValue << FLT_MAX;
1001 std::string floatMax = tempValue.str();
1002 tempValue.str("");
1003 tempValue << FLT_MIN;
1004 predicates1.Between("floatValue", tempValue.str(), floatMax);
1005 std::unique_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1006 EXPECT_EQ(3, ResultSize(allDataTypes5));
1007
1008 predicates1.Clear();
1009 std::vector<int> lowCalendar = {2019, 6, 9};
1010 time_t lowCalendarTime = RdbStorePredicateTest::DateMakeTime(lowCalendar);
1011 std::vector<int> highCalendar = {2019, 7, 17};
1012 time_t highCalendarTime = RdbStorePredicateTest::DateMakeTime(highCalendar);
1013 predicates1.Between("timeValue", std::to_string(lowCalendarTime).c_str(), std::to_string(highCalendarTime).c_str());
1014 std::unique_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1015 EXPECT_EQ(3, ResultSize(allDataTypes6));
1016 }
1017
1018 /* *
1019 * @tc.name: RdbStore_Contain_010
1020 * @tc.desc: Normal testCase of RdbPredicates for Contain
1021 * @tc.type: FUNC
1022 * @tc.require: AR000FKD4F
1023 */
1024 HWTEST_F(RdbStorePredicateTest, RdbStore_Contain_010, TestSize.Level1)
1025 {
1026 RdbPredicates predicates1("AllDataType");
1027 std::vector<std::string> columns;
1028
1029 predicates1.Contains("stringValue", "DEF");
1030 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1031 EXPECT_EQ(3, ResultSize(allDataTypes1));
1032 }
1033
1034 /* *
1035 * @tc.name: RdbStore_BeginsWith_011
1036 * @tc.desc: Normal testCase of RdbPredicates for BeginsWith
1037 * @tc.type: FUNC
1038 * @tc.require: AR000FKD4F
1039 */
1040 HWTEST_F(RdbStorePredicateTest, RdbStore_BeginsWith_011, TestSize.Level1)
1041 {
1042 RdbPredicates predicates1("AllDataType");
1043 std::vector<std::string> columns;
1044
1045 predicates1.BeginsWith("stringValue", "ABC");
1046 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1047 EXPECT_EQ(3, ResultSize(allDataTypes1));
1048 }
1049
1050 /* *
1051 * @tc.name: RdbStore_EndsWith_012
1052 * @tc.desc: Normal testCase of RdbPredicates for EndsWith
1053 * @tc.type: FUNC
1054 * @tc.require: AR000FKD4F
1055 */
1056 HWTEST_F(RdbStorePredicateTest, RdbStore_EndsWith_012, TestSize.Level1)
1057 {
1058 RdbPredicates predicates1("AllDataType");
1059 std::vector<std::string> columns;
1060
1061 predicates1.EndsWith("stringValue", "LMN");
1062 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1063 EXPECT_EQ(3, ResultSize(allDataTypes1));
1064 }
1065
1066 /* *
1067 * @tc.name: RdbStore_Like_013
1068 * @tc.desc: Normal testCase of RdbPredicates for Like
1069 * @tc.type: FUNC
1070 * @tc.require: AR000FKD4F
1071 */
1072 HWTEST_F(RdbStorePredicateTest, RdbStore_Like_013, TestSize.Level1)
1073 {
1074 RdbPredicates predicates1("AllDataType");
1075 std::vector<std::string> columns;
1076
1077 predicates1.Like("stringValue", "%LMN%");
1078 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1079 EXPECT_EQ(3, ResultSize(allDataTypes1));
1080 }
1081
1082 /* *
1083 * @tc.name: RdbStore_BeginEndWrap_014
1084 * @tc.desc: Normal testCase of RdbPredicates for BeginEndWrap
1085 * @tc.type: FUNC
1086 * @tc.require: AR000FKD4F
1087 */
1088 HWTEST_F(RdbStorePredicateTest, RdbStore_BeginEndWrap_014, TestSize.Level1)
1089 {
1090 RdbPredicates predicates1("AllDataType");
1091 std::vector<std::string> columns;
1092
1093 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1094 ->BeginWrap()
1095 ->EqualTo("integerValue", "1")
1096 ->Or()
1097 ->EqualTo("integerValue", std::to_string(INT_MAX))
1098 ->EndWrap();
1099 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1100 EXPECT_EQ(2, ResultSize(allDataTypes1));
1101
1102 predicates1.Clear();
1103 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->And()->EqualTo("integerValue", "1");
1104 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1105 EXPECT_EQ(1, ResultSize(allDataTypes2));
1106 }
1107
1108 /* *
1109 * @tc.name: RdbStore_AndOR_015
1110 * @tc.desc: Normal testCase of RdbPredicates for AndOR
1111 * @tc.type: FUNC
1112 * @tc.require: AR000FKD4F
1113 */
1114 HWTEST_F(RdbStorePredicateTest, RdbStore_AndOR_015, TestSize.Level1)
1115 {
1116 RdbPredicates predicates1("AllDataType");
1117 std::vector<std::string> columns;
1118
1119 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1120 ->BeginWrap()
1121 ->EqualTo("integerValue", "1")
1122 ->Or()
1123 ->EqualTo("integerValue", std::to_string(INT_MAX))
1124 ->EndWrap();
1125
1126 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1127 EXPECT_EQ(2, ResultSize(allDataTypes1));
1128
1129 predicates1.Clear();
1130 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->And()->EqualTo("integerValue", "1");
1131 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1132 EXPECT_EQ(1, ResultSize(allDataTypes2));
1133 }
1134
1135 /* *
1136 * @tc.name: RdbStore_Order_016
1137 * @tc.desc: Normal testCase of RdbPredicates for Order
1138 * @tc.type: FUNC
1139 * @tc.require: AR000FKD4F
1140 */
1141 HWTEST_F(RdbStorePredicateTest, RdbStore_Order_016, TestSize.Level1)
1142 {
1143 RdbPredicates predicates1("AllDataType");
1144 std::vector<std::string> columns;
1145
1146 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->OrderByAsc("integerValue")->Distinct();
1147 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1148 EXPECT_EQ(E_OK, allDataTypes1->GoToFirstRow());
1149 int valueInt = 0;
1150 allDataTypes1->GetInt(0, valueInt);
1151 EXPECT_EQ(3, valueInt);
1152 EXPECT_EQ(E_OK, allDataTypes1->GoToNextRow());
1153 allDataTypes1->GetInt(0, valueInt);
1154 EXPECT_EQ(2, valueInt);
1155 EXPECT_EQ(E_OK, allDataTypes1->GoToNextRow());
1156 allDataTypes1->GetInt(0, valueInt);
1157 EXPECT_EQ(1, valueInt);
1158
1159 predicates1.Clear();
1160 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->OrderByDesc("integerValue")->Distinct();
1161 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1162 EXPECT_EQ(E_OK, allDataTypes2->GoToFirstRow());
1163 allDataTypes2->GetInt(0, valueInt);
1164 EXPECT_EQ(1, valueInt);
1165 EXPECT_EQ(E_OK, allDataTypes2->GoToNextRow());
1166 allDataTypes2->GetInt(0, valueInt);
1167 EXPECT_EQ(2, valueInt);
1168 EXPECT_EQ(E_OK, allDataTypes2->GoToNextRow());
1169 allDataTypes2->GetInt(0, valueInt);
1170 EXPECT_EQ(3, valueInt);
1171 }
1172
1173 /* *
1174 * @tc.name: RdbStore_Limit_017
1175 * @tc.desc: Normal testCase of RdbPredicates for Limit
1176 * @tc.type: FUNC
1177 * @tc.require: AR000FKD4F
1178 */
1179 HWTEST_F(RdbStorePredicateTest, RdbStore_Limit_017, TestSize.Level1)
1180 {
1181 RdbPredicates predicates1("AllDataType");
1182 std::vector<std::string> columns;
1183
1184 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")->Limit(1);
1185 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1186 EXPECT_EQ(1, ResultSize(allDataTypes1));
1187 }
1188
1189 /* *
1190 * @tc.name: RdbStore_JoinTypes_018
1191 * @tc.desc: Normal testCase of RdbPredicates for JoinTypes
1192 * @tc.type: FUNC
1193 * @tc.require: AR000FKD4F
1194 */
1195 HWTEST_F(RdbStorePredicateTest, RdbStore_JoinTypes_018, TestSize.Level1)
1196 {
1197 RdbPredicates predicates1("AllDataType");
1198 std::vector<std::string> joinEntityNames;
1199
1200 joinEntityNames.push_back("AllDataType");
1201 predicates1.SetJoinTableNames(joinEntityNames);
1202
1203 std::vector<std::string> joinTypes;
1204 joinTypes.push_back("INNER JOIN");
1205 predicates1.SetJoinTypes(joinTypes);
1206
1207 std::vector<std::string> joinConditions;
1208 joinConditions.push_back("ON");
1209 predicates1.SetJoinConditions(joinConditions);
1210 predicates1.SetJoinCount(1);
1211
1212 EXPECT_EQ(joinConditions, predicates1.GetJoinConditions());
1213 EXPECT_EQ(joinEntityNames, predicates1.GetJoinTableNames());
1214 EXPECT_EQ(joinTypes, predicates1.GetJoinTypes());
1215 EXPECT_EQ(1, predicates1.GetJoinCount());
1216 }
1217
1218 /* *
1219 * @tc.name: RdbStore_Glob_019
1220 * @tc.desc: Normal testCase of RdbPredicates for Glob
1221 * @tc.type: FUNC
1222 * @tc.require: AR000FKD4F
1223 */
1224 HWTEST_F(RdbStorePredicateTest, RdbStore_Glob_019, TestSize.Level1)
1225 {
1226 RdbPredicates predicates1("AllDataType");
1227 std::vector<std::string> columns;
1228
1229 predicates1.Glob("stringValue", "ABC*");
1230 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1231 EXPECT_EQ(3, ResultSize(allDataTypes1));
1232
1233 predicates1.Clear();
1234 predicates1.Glob("stringValue", "*EFG*");
1235 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1236 EXPECT_EQ(3, ResultSize(allDataTypes2));
1237
1238 predicates1.Clear();
1239 predicates1.Glob("stringValue", "?B*");
1240 std::unique_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
1241 EXPECT_EQ(3, ResultSize(allDataTypes3));
1242
1243 predicates1.Clear();
1244 predicates1.Glob("stringValue", "A????????????N");
1245 std::unique_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
1246 EXPECT_EQ(3, ResultSize(allDataTypes4));
1247
1248 predicates1.Clear();
1249 predicates1.Glob("stringValue", "A?????????????N");
1250 std::unique_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1251 EXPECT_EQ(0, ResultSize(allDataTypes5));
1252
1253 predicates1.Clear();
1254 predicates1.Glob("stringValue", "?B*N");
1255 std::unique_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1256 EXPECT_EQ(3, ResultSize(allDataTypes6));
1257 }
1258
1259 /* *
1260 * @tc.name: RdbStore_NotBetween_020
1261 * @tc.desc: Normal testCase of RdbPredicates for NotBetween
1262 * @tc.type: FUNC
1263 * @tc.require: AR000FKD4F
1264 */
1265 HWTEST_F(RdbStorePredicateTest, RdbStore_NotBetween_020, TestSize.Level1)
1266 {
1267 RdbPredicates predicates1("AllDataType");
1268 std::vector<std::string> columns;
1269 std::stringstream tempValue;
1270
1271 predicates1.NotBetween("stringValue", "ABB", "ABD");
1272 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1273 EXPECT_EQ(0, ResultSize(allDataTypes1));
1274
1275 predicates1.Clear();
1276 tempValue.str("");
1277 tempValue << DBL_MAX;
1278 predicates1.NotBetween("doubleValue", "0.0", tempValue.str());
1279 std::unique_ptr<ResultSet> allDataTypes2 = RdbStorePredicateTest::store->Query(predicates1, columns);
1280 EXPECT_EQ(0, ResultSize(allDataTypes2));
1281
1282 predicates1.Clear();
1283 predicates1.NotBetween("integerValue", "0", "1");
1284 std::unique_ptr<ResultSet> allDataTypes3 = RdbStorePredicateTest::store->Query(predicates1, columns);
1285 EXPECT_EQ(2, ResultSize(allDataTypes3));
1286
1287 predicates1.Clear();
1288 predicates1.NotBetween("longValue", "0", "2");
1289 std::unique_ptr<ResultSet> allDataTypes4 = RdbStorePredicateTest::store->Query(predicates1, columns);
1290 EXPECT_EQ(2, ResultSize(allDataTypes4));
1291
1292 predicates1.Clear();
1293 tempValue.str("");
1294 tempValue << FLT_MAX;
1295 std::string floatMax = tempValue.str();
1296 tempValue.str("");
1297 tempValue << FLT_MIN;
1298 predicates1.NotBetween("floatValue", tempValue.str(), floatMax);
1299 std::unique_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
1300 EXPECT_EQ(0, ResultSize(allDataTypes5));
1301
1302 std::vector<int> lowCalendar = {2019, 6, 9};
1303 time_t lowCalendarTime = RdbStorePredicateTest::DateMakeTime(lowCalendar);
1304 std::vector<int> highCalendar = {2019, 7, 17};
1305 time_t highCalendarTime = RdbStorePredicateTest::DateMakeTime(highCalendar);
1306 predicates1.Clear();
1307 predicates1.NotBetween("timeValue", std::to_string(lowCalendarTime), std::to_string(highCalendarTime));
1308 std::unique_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
1309 EXPECT_EQ(0, ResultSize(allDataTypes6));
1310 }
1311
1312 /* *
1313 * @tc.name: RdbStore_ComplexPredicate_021
1314 * @tc.desc: Normal testCase of RdbPredicates for complex combine sql
1315 * @tc.type: FUNC
1316 * @tc.require: AR000FKD4F
1317 */
1318 HWTEST_F(RdbStorePredicateTest, RdbStore_ComplexPredicate_021, TestSize.Level1)
1319 {
1320 RdbPredicates predicates1("AllDataType");
1321 std::vector<std::string> columns;
1322
1323 predicates1.Glob("stringValue", "ABC*")->EqualTo("booleanValue", "1")
1324 ->NotBetween("longValue", "0", "2");
1325 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1326 EXPECT_EQ(1, ResultSize(allDataTypes1));
1327 }
1328
1329 /* *
1330 * @tc.name: RdbStore_ClearMethod_022
1331 * @tc.desc: Normal testCase of RdbPredicates for Clear Method
1332 * @tc.type: FUNC
1333 * @tc.require: AR000FKD4F
1334 */
1335 HWTEST_F(RdbStorePredicateTest, RdbStore_ClearMethod_022, TestSize.Level1)
1336 {
1337 RdbPredicates predicates1("AllDataType");
1338 std::vector<std::string> columns;
1339
1340 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1341 ->BeginWrap()
1342 ->EqualTo("integerValue", "1")
1343 ->Or()
1344 ->EqualTo("integerValue", std::to_string(INT_MAX))
1345 ->EndWrap()
1346 ->OrderByDesc("integerValue")
1347 ->Limit(2);
1348
1349 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1350 EXPECT_EQ(2, ResultSize(allDataTypes1));
1351
1352 EXPECT_EQ("AllDataType", predicates1.GetTableName());
1353 EXPECT_EQ(2, predicates1.GetLimit());
1354 EXPECT_EQ(true, predicates1.GetWhereClause().find("stringValue") != std::string::npos);
1355
1356 std::vector<std::string> agrs = predicates1.GetWhereArgs();
1357 auto ret = find(agrs.begin(), agrs.end(), "ABCDEFGHIJKLMN");
1358 EXPECT_EQ(true, ret != agrs.end());
1359
1360 std::vector<std::string> lists = {"ohos", "bazhahei", "zhaxidelie"};
1361 predicates1.SetJoinTableNames(lists);
1362 predicates1.SetJoinCount(1);
1363 predicates1.SetJoinConditions(lists);
1364 predicates1.SetJoinTypes(lists);
1365 predicates1.SetOrder("ohos");
1366 predicates1.Distinct();
1367
1368 agrs = predicates1.GetJoinTableNames();
1369 ret = find(agrs.begin(), agrs.end(), "zhaxidelie");
1370 EXPECT_EQ(true, ret != agrs.end());
1371 EXPECT_EQ(1, predicates1.GetJoinCount());
1372
1373 agrs = predicates1.GetJoinConditions();
1374 ret = find(agrs.begin(), agrs.end(), "zhaxidelie");
1375 EXPECT_EQ(true, ret != agrs.end());
1376
1377 agrs = predicates1.GetJoinTypes();
1378 ret = find(agrs.begin(), agrs.end(), "zhaxidelie");
1379 EXPECT_EQ(true, ret != agrs.end());
1380 EXPECT_EQ(true, predicates1.GetJoinClause().find("ohos") != std::string::npos);
1381 EXPECT_EQ("ohos", predicates1.GetOrder());
1382 EXPECT_EQ(true, predicates1.IsDistinct());
1383
1384 predicates1.Clear();
1385 EXPECT_EQ("AllDataType", predicates1.GetTableName());
1386 EXPECT_EQ(-1, predicates1.GetLimit());
1387 EXPECT_EQ(true, predicates1.GetWhereClause().empty());
1388 EXPECT_EQ(true, predicates1.GetWhereArgs().empty());
1389
1390 EXPECT_EQ(true, predicates1.GetJoinTableNames().empty());
1391 EXPECT_EQ(0, predicates1.GetJoinCount());
1392 EXPECT_EQ(true, predicates1.GetJoinConditions().empty());
1393 EXPECT_EQ(true, predicates1.GetJoinTypes().empty());
1394 EXPECT_EQ("AllDataType", predicates1.GetJoinClause());
1395 EXPECT_EQ(true, predicates1.GetOrder().empty());
1396 EXPECT_EQ(false, predicates1.IsDistinct());
1397 }
1398
1399 /* *
1400 * @tc.name: RdbStore_InMethod_023
1401 * @tc.desc: Normal testCase of RdbPredicates for in method
1402 * @tc.type: FUNC
1403 * @tc.require: AR000FKD4F
1404 */
1405 HWTEST_F(RdbStorePredicateTest, RdbStore_InMethod_023, TestSize.Level1)
1406 {
1407 RdbPredicates rdbPredicates1("AllDataType");
1408 std::vector<std::string> columns;
1409 std::vector<std::string> agrs = {std::to_string(INT_MAX)};
1410 rdbPredicates1.In("integerValue", agrs);
1411 std::unique_ptr<ResultSet> resultSet1 = RdbStorePredicateTest::store->Query(rdbPredicates1, columns);
1412 int count = 0;
1413 resultSet1->GetRowCount(count);
1414 EXPECT_EQ(1, count);
1415
1416 RdbPredicates rdbPredicates2("AllDataType");
1417 agrs[0] = "1";
1418 rdbPredicates2.In("longValue", agrs);
1419 std::unique_ptr<ResultSet> resultSet2 = RdbStorePredicateTest::store->Query(rdbPredicates2, columns);
1420 resultSet2->GetRowCount(count);
1421 EXPECT_EQ(1, count);
1422
1423 RdbPredicates rdbPredicates3("AllDataType");
1424 agrs[0] = "1.0";
1425 rdbPredicates3.In("doubleValue", agrs);
1426 std::unique_ptr<ResultSet> resultSet3 = RdbStorePredicateTest::store->Query(rdbPredicates3, columns);
1427 resultSet3->GetRowCount(count);
1428 EXPECT_EQ(1, count);
1429
1430 RdbPredicates rdbPredicates4("AllDataType");
1431 rdbPredicates4.In("floatValue", agrs);
1432 std::unique_ptr<ResultSet> resultSet4 = RdbStorePredicateTest::store->Query(rdbPredicates4, columns);
1433 resultSet4->GetRowCount(count);
1434 EXPECT_EQ(1, count);
1435
1436 std::vector<int> date = {2019, 6, 10};
1437 time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
1438 RdbPredicates rdbPredicates5("AllDataType");
1439 agrs[0] = std::to_string(calendarTime);
1440 rdbPredicates5.In("timeValue", agrs);
1441 std::unique_ptr<ResultSet> resultSet5 = RdbStorePredicateTest::store->Query(rdbPredicates5, columns);
1442 resultSet5->GetRowCount(count);
1443 EXPECT_EQ(1, count);
1444 }
1445
1446 /* *
1447 * @tc.name: RdbStore_NotInMethod_023
1448 * @tc.desc: Normal testCase of RdbPredicates for notIn method
1449 * @tc.type: FUNC
1450 * @tc.require: AR000FKD4F
1451 */
1452 HWTEST_F(RdbStorePredicateTest, RdbStore_NotInMethod_023, TestSize.Level1)
1453 {
1454 std::vector<std::string> columns;
1455 std::vector<std::string> agrs = {std::to_string(INT_MAX), std::to_string(INT_MIN)};
1456 std::stringstream tempValue;
1457
1458 RdbPredicates rdbPredicates1("AllDataType");
1459 rdbPredicates1.NotIn("integerValue", agrs);
1460 std::unique_ptr<ResultSet> resultSet1 = RdbStorePredicateTest::store->Query(rdbPredicates1, columns);
1461 int count = 0;
1462 resultSet1->GetRowCount(count);
1463 EXPECT_EQ(1, count);
1464
1465 RdbPredicates rdbPredicates2("AllDataType");
1466 agrs[0] = "1";
1467 agrs[1] = std::to_string(LONG_MAX);
1468 rdbPredicates2.NotIn("longValue", agrs);
1469 std::unique_ptr<ResultSet> resultSet2 = RdbStorePredicateTest::store->Query(rdbPredicates2, columns);
1470 resultSet2->GetRowCount(count);
1471 EXPECT_EQ(1, count);
1472
1473 RdbPredicates rdbPredicates3("AllDataType");
1474 tempValue.str("");
1475 tempValue << DBL_MIN;
1476 agrs[0] = "1.0";
1477 agrs[1] = tempValue.str();
1478 rdbPredicates3.NotIn("doubleValue", agrs);
1479 std::unique_ptr<ResultSet> resultSet3 = RdbStorePredicateTest::store->Query(rdbPredicates3, columns);
1480 resultSet3->GetRowCount(count);
1481 EXPECT_EQ(1, count);
1482
1483 RdbPredicates rdbPredicates4("AllDataType");
1484 tempValue.str("");
1485 tempValue << FLT_MAX;
1486 agrs[0] = "1.0";
1487 agrs[1] = tempValue.str();
1488 rdbPredicates4.NotIn("floatValue", agrs);
1489 std::unique_ptr<ResultSet> resultSet4 = RdbStorePredicateTest::store->Query(rdbPredicates4, columns);
1490 resultSet4->GetRowCount(count);
1491 EXPECT_EQ(1, count);
1492 }
1493
1494 /* *
1495 * @tc.name: RdbStore_KeywordMethod_024
1496 * @tc.desc: Normal testCase of RdbPredicates for clear method
1497 * @tc.type: FUNC
1498 * @tc.require: AR000FKD4F
1499 */
1500 HWTEST_F(RdbStorePredicateTest, RdbStore_KeywordMethod_024, TestSize.Level1)
1501 {
1502 RdbPredicates predicates1("AllDataType");
1503 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1504 ->BeginWrap()
1505 ->EqualTo("integerValue", "1")
1506 ->Or()
1507 ->EqualTo("integerValue", std::to_string(INT_MAX))
1508 ->EndWrap()->OrderByDesc("integerValue")->Limit(2);
1509 std::vector<std::string> columns = {"booleanValue", "doubleValue", "order"};
1510 std::unique_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
1511 allDataTypes1->GoToFirstRow();
1512 EXPECT_EQ(2, ResultSize(allDataTypes1));
1513
1514 EXPECT_EQ("AllDataType", predicates1.GetTableName());
1515 EXPECT_EQ(2, predicates1.GetLimit());
1516
1517 EXPECT_EQ(true, predicates1.GetWhereClause().find("stringValue") != std::string::npos);
1518 std::vector<std::string> agrs = predicates1.GetWhereArgs();
1519 auto ret = find(agrs.begin(), agrs.end(), "ABCDEFGHIJKLMN");
1520 EXPECT_EQ(true, ret != agrs.end());
1521
1522 std::vector<std::string> lists = {"ohos", "bazhahei", "zhaxidelie"};
1523 predicates1.SetJoinTableNames(lists);
1524 predicates1.SetJoinCount(1);
1525 predicates1.SetJoinConditions(lists);
1526 predicates1.SetJoinTypes(lists);
1527 predicates1.SetOrder("ohos");
1528 predicates1.Distinct();
1529
1530 agrs = predicates1.GetJoinTableNames();
1531 ret = find(agrs.begin(), agrs.end(), "zhaxidelie");
1532 EXPECT_EQ(true, ret != agrs.end());
1533 EXPECT_EQ(1, predicates1.GetJoinCount());
1534
1535 agrs = predicates1.GetJoinConditions();
1536 ret = find(agrs.begin(), agrs.end(), "zhaxidelie");
1537 EXPECT_EQ(true, ret != agrs.end());
1538
1539 agrs = predicates1.GetJoinTypes();
1540 ret = find(agrs.begin(), agrs.end(), "zhaxidelie");
1541 EXPECT_EQ(true, ret != agrs.end());
1542 EXPECT_EQ(true, predicates1.GetJoinClause().find("ohos") != std::string::npos);
1543 EXPECT_EQ("ohos", predicates1.GetOrder());
1544 EXPECT_EQ(true, predicates1.IsDistinct());
1545
1546 predicates1.Clear();
1547 EXPECT_EQ("AllDataType", predicates1.GetTableName());
1548 EXPECT_EQ(-1, predicates1.GetLimit());
1549 EXPECT_EQ(true, predicates1.GetWhereClause().empty());
1550 EXPECT_EQ(true, predicates1.GetWhereArgs().empty());
1551
1552 EXPECT_EQ(true, predicates1.GetJoinTableNames().empty());
1553 EXPECT_EQ(0, predicates1.GetJoinCount());
1554 EXPECT_EQ(true, predicates1.GetJoinConditions().empty());
1555 EXPECT_EQ(true, predicates1.GetJoinTypes().empty());
1556 EXPECT_EQ("AllDataType", predicates1.GetJoinClause());
1557 EXPECT_EQ(true, predicates1.GetOrder().empty());
1558 EXPECT_EQ(false, predicates1.IsDistinct());
1559 }
1560
1561 /* *
1562 * @tc.name: RdbStore_ToString_025
1563 * @tc.desc: Normal testCase of RdbPredicates for clear method
1564 * @tc.type: FUNC
1565 * @tc.require: AR000FKD4F
1566 */
1567 HWTEST_F(RdbStorePredicateTest, RdbStore_ToString_025, TestSize.Level1)
1568 {
1569 RdbPredicates predicates1("AllDataType");
1570 predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
1571 ->BeginWrap()
1572 ->EqualTo("integerValue", "1")
1573 ->Or()
1574 ->EqualTo("integerValue", std::to_string(INT_MAX))
1575 ->EndWrap()
1576 ->OrderByDesc("integerValue")
1577 ->Limit(2);
1578 std::string toString = predicates1.ToString();
1579 std::string result = "TableName = AllDataType, {WhereClause:`stringValue` = ? AND ( `integerValue` = ? OR "
1580 "`integerValue` = ? ) , whereArgs:{ABCDEFGHIJKLMN, 1, 2147483647, }, order:`integerValue` "
1581 "DESC , group:, index:, limit:2, offset:-1, distinct:0, isNeedAnd:1, isSorted:1}";
1582 EXPECT_EQ(result, toString);
1583 }