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