1 /*
2 * Copyright (c) 2022 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 #define LOG_TAG "RdbDataShareAdapterTest"
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include <string>
20
21 #include "datashare_predicates.h"
22 #include "logger.h"
23 #include "rdb_errno.h"
24 #include "rdb_helper.h"
25 #include "rdb_open_callback.h"
26 #include "rdb_utils.h"
27
28 using namespace testing::ext;
29 using namespace OHOS::Rdb;
30 using namespace OHOS::NativeRdb;
31 using namespace OHOS::DataShare;
32 using namespace OHOS::RdbDataShareAdapter;
33
34 class MockRdbPredicates : public RdbPredicates {
35 public:
MockRdbPredicates(const std::string & table)36 explicit MockRdbPredicates(const std::string &table) : RdbPredicates(table)
37 {
38 }
39 MOCK_METHOD(AbsRdbPredicates *, EqualTo, (const std::string &field, const ValueObject &value), (override));
40 MOCK_METHOD(AbsRdbPredicates *, NotEqualTo, (const std::string &column, const OHOS::NativeRdb::ValueObject &value),
41 (override));
42 MOCK_METHOD(AbsRdbPredicates *, GreaterThan,
43 (const std::string &column, const OHOS::NativeRdb::ValueObject &value), (override));
44 MOCK_METHOD(AbsRdbPredicates *, LessThan, (const std::string &field, const ValueObject &value), (override));
45 MOCK_METHOD(AbsRdbPredicates *, GreaterThanOrEqualTo,
46 (const std::string &column, const OHOS::NativeRdb::ValueObject &value), (override));
47 MOCK_METHOD(AbsRdbPredicates *, LessThanOrEqualTo,
48 (const std::string &column, const OHOS::NativeRdb::ValueObject &value), (override));
49 MOCK_METHOD(AbsRdbPredicates *, And, (), (override));
50 MOCK_METHOD(AbsRdbPredicates *, Or, (), (override));
51 MOCK_METHOD(AbsRdbPredicates *, IsNull, (const std::string &column), (override));
52 MOCK_METHOD(AbsRdbPredicates *, IsNotNull, (const std::string &column), (override));
53 MOCK_METHOD(AbsRdbPredicates *, In, (const std::string &field, const std::vector<ValueObject> &values), (override));
54 MOCK_METHOD(
55 AbsRdbPredicates *, NotIn, (const std::string &field, const std::vector<ValueObject> &values), (override));
56 MOCK_METHOD(AbsRdbPredicates *, Like, (const std::string &field, const std::string &value), (override));
57 MOCK_METHOD(AbsRdbPredicates *, NotLike, (const std::string &field, const std::string &value), (override));
58 MOCK_METHOD(AbsRdbPredicates *, OrderByAsc, (const std::string &field), (override));
59 MOCK_METHOD(AbsRdbPredicates *, OrderByDesc, (const std::string &field), (override));
60 MOCK_METHOD(AbsRdbPredicates *, Offset, (const int offset), (override));
61 MOCK_METHOD(AbsRdbPredicates *, BeginsWith, (const std::string &field, const std::string &value), (override));
62 MOCK_METHOD(AbsRdbPredicates *, EndsWith, (const std::string &field, const std::string &value), (override));
63 MOCK_METHOD(AbsRdbPredicates *, GroupBy, (const std::vector<std::string> &fields), (override));
64 MOCK_METHOD(AbsRdbPredicates *, IndexedBy, (const std::string &indexName), (override));
65 MOCK_METHOD(AbsRdbPredicates *, Contains, (const std::string &field, const std::string &value), (override));
66 MOCK_METHOD(AbsRdbPredicates *, NotContains, (const std::string &field, const std::string &value), (override));
67 MOCK_METHOD(AbsRdbPredicates *, Glob, (const std::string &field, const std::string &value), (override));
68 MOCK_METHOD(AbsRdbPredicates *, Between,
69 (const std::string &field, const ValueObject &low, const ValueObject &high), (override));
70 MOCK_METHOD(AbsRdbPredicates *, NotBetween,
71 (const std::string &field, const ValueObject &low, const ValueObject &high), (override));
72 };
73 class RdbDataShareAdapterTest : public testing::Test {
74 public:
75 static void SetUpTestCase(void);
76 static void TearDownTestCase(void);
77 void SetUp();
78 void TearDown();
79 void GenerateDefaultTable();
80 void GenerateDefaultEmptyTable();
81 int ResultSize(std::shared_ptr<ResultSet> resultSet);
82 OperationItem CreateOperationItem(int operation, const std::vector<SingleValue::Type> &singleParams,
83 const std::vector<MutliValue::Type> &multiParams);
84 void LessThanTest(MockRdbPredicates &predicates);
85 void GreaterThanOrEqualTo(MockRdbPredicates &predicates);
86 void LessThanOrEqualTo(MockRdbPredicates &predicates);
87 void IsNull(MockRdbPredicates &predicates);
88 void IsNotNull(MockRdbPredicates &predicates);
89 void In(MockRdbPredicates &predicates);
90 void NotIn(MockRdbPredicates &predicates);
91 void Like(MockRdbPredicates &predicates);
92 void NotLike(MockRdbPredicates &predicates);
93 void OrderByAsc(MockRdbPredicates &predicates);
94 void OrderByDesc(MockRdbPredicates &predicates);
95 void Offset(MockRdbPredicates &predicates);
96 void BeginsWith(MockRdbPredicates &predicates);
97 void EndsWith(MockRdbPredicates &predicates);
98 void GroupBy(MockRdbPredicates &predicates);
99 void IndexedBy(MockRdbPredicates &predicates);
100 void Contains(MockRdbPredicates &predicates);
101 void NotContains(MockRdbPredicates &predicates);
102 void Glob(MockRdbPredicates &predicates);
103 void Between(MockRdbPredicates &predicates);
104 void NotBetween(MockRdbPredicates &predicates);
105 static const std::string DATABASE_NAME;
106 static std::shared_ptr<RdbStore> store;
107 static const std::string RDB_ADAPTER_TEST_PATH;
108 };
109 const std::string RdbDataShareAdapterTest::RDB_ADAPTER_TEST_PATH = "/data/test/";
110 const std::string RdbDataShareAdapterTest::DATABASE_NAME = RDB_ADAPTER_TEST_PATH + "rdbDataShareAdapter_test.db";
111 std::shared_ptr<RdbStore> RdbDataShareAdapterTest::store = nullptr;
112
113 class RdbStepSharedResultSetOpenCallback : public RdbOpenCallback {
114 public:
115 int OnCreate(RdbStore &store) override;
116
117 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
118
119 static const std::string CREATE_TABLE_TEST;
120 };
121
OnCreate(RdbStore & store)122 int RdbStepSharedResultSetOpenCallback::OnCreate(RdbStore &store)
123 {
124 return OHOS::NativeRdb::E_OK;
125 }
126
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)127 int RdbStepSharedResultSetOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
128 {
129 return OHOS::NativeRdb::E_OK;
130 }
131
SetUpTestCase(void)132 void RdbDataShareAdapterTest::SetUpTestCase(void)
133 {
134 int errCode = OHOS::NativeRdb::E_OK;
135 RdbStoreConfig config(RdbDataShareAdapterTest::DATABASE_NAME);
136 RdbStepSharedResultSetOpenCallback helper;
137 RdbDataShareAdapterTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
138 EXPECT_NE(RdbDataShareAdapterTest::store, nullptr);
139 EXPECT_EQ(errCode, OHOS::NativeRdb::E_OK);
140 }
141
TearDownTestCase(void)142 void RdbDataShareAdapterTest::TearDownTestCase(void)
143 {
144 RdbHelper::DeleteRdbStore(RdbDataShareAdapterTest::DATABASE_NAME);
145 }
146
SetUp(void)147 void RdbDataShareAdapterTest::SetUp(void)
148 {
149 store->ExecuteSql("DROP TABLE IF EXISTS test");
150 }
151
TearDown(void)152 void RdbDataShareAdapterTest::TearDown(void)
153 {
154 RdbHelper::ClearCache();
155 }
156
GenerateDefaultTable()157 void RdbDataShareAdapterTest::GenerateDefaultTable()
158 {
159 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
160 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
161 store->ExecuteSql(createTableSql);
162
163 std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
164
165 /* insert first entry data */
166 uint8_t uValue = 66;
167 std::vector<uint8_t> typeBlob;
168 typeBlob.push_back(uValue);
169 store->ExecuteSql(insertSql, std::vector<ValueObject>{ ValueObject(std::string("hello")), ValueObject((int)10),
170 ValueObject((double)1.0), ValueObject((std::vector<uint8_t>)typeBlob) });
171
172 /* insert second entry data */
173 typeBlob.clear();
174 store->ExecuteSql(insertSql, std::vector<ValueObject>{
175 ValueObject(std::string("2")), ValueObject((int)-5), ValueObject((double)2.5),
176 ValueObject() // set double value 2.5
177 });
178
179 /* insert third entry data */
180 store->ExecuteSql(
181 insertSql, std::vector<ValueObject>{
182 ValueObject(std::string("hello world")), ValueObject((int)3), ValueObject((double)1.8),
183 ValueObject(std::vector<uint8_t>{ 4, 5, 6 }) // set int value 3, double 1.8
184 });
185
186 /* insert four entry data */
187 store->ExecuteSql(insertSql, std::vector<ValueObject>{
188 ValueObject(std::string("new world")), ValueObject((int)5),
189 ValueObject((double)5.8), ValueObject() // set int value 5, double 5.8
190 });
191 }
192
GenerateDefaultEmptyTable()193 void RdbDataShareAdapterTest::GenerateDefaultEmptyTable()
194 {
195 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
196 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
197 store->ExecuteSql(createTableSql);
198 }
199
ResultSize(std::shared_ptr<ResultSet> resultSet)200 int RdbDataShareAdapterTest::ResultSize(std::shared_ptr<ResultSet> resultSet)
201 {
202 if (resultSet->GoToFirstRow() != OHOS::NativeRdb::E_OK) {
203 return 0;
204 }
205 int count = 1;
206 while (resultSet->GoToNextRow() == OHOS::NativeRdb::E_OK) {
207 count++;
208 }
209 return count;
210 }
211
CreateOperationItem(int operation,const std::vector<SingleValue::Type> & singleParams={},const std::vector<MutliValue::Type> & multiParams={})212 OperationItem RdbDataShareAdapterTest::CreateOperationItem(int operation,
213 const std::vector<SingleValue::Type> &singleParams = {}, const std::vector<MutliValue::Type> &multiParams = {})
214 {
215 OperationItem item;
216 item.operation = operation;
217 item.singleParams = singleParams;
218 item.multiParams = multiParams;
219 return item;
220 }
221
222 /* *
223 * @tc.name: Rdb_DataShare_Adapter_001
224 * @tc.desc: test RdbDataShareAdapter
225 * @tc.type: FUNC
226 */
227 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_001, TestSize.Level1)
228 {
229 GenerateDefaultTable();
230
231 std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
232 EXPECT_NE(resultSet, nullptr);
233 int rowCount;
234 resultSet.get()->GetRowCount(rowCount);
235 LOG_INFO("result row count: %{public}d", rowCount);
236 EXPECT_NE(rowCount, 0);
237 auto bridge = OHOS::RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
238 EXPECT_NE(bridge, nullptr);
239 }
240
241 /* *
242 * @tc.name: Rdb_DataShare_Adapter_002
243 * @tc.desc: normal testcase of RdbDataShareAdapter
244 * @tc.type: FUNC
245 */
246 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_002, TestSize.Level1)
247 {
248 GenerateDefaultTable();
249
250 std::string table = "test";
251 std::string column = "data1";
252 std::string value = "hello";
253 DataSharePredicates predicates;
254 predicates.EqualTo(column, value);
255 std::vector<std::string> columns;
256 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
257 int rowCount;
258 allDataTypes.get()->GetRowCount(rowCount);
259 EXPECT_EQ(rowCount, 1);
260 }
261
262 /* *
263 * @tc.name: Rdb_DataShare_Adapter_003
264 * @tc.desc: normal testcase of RdbDataShareAdapter
265 * @tc.type: FUNC
266 */
267 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_003, TestSize.Level1)
268 {
269 GenerateDefaultTable();
270
271 std::string table = "test";
272 OHOS::DataShare::DataSharePredicates predicates;
273 predicates.GreaterThan("data2", -5);
274 std::vector<std::string> columns;
275 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
276 int rdbRowCount;
277 allDataTypes.get()->GetRowCount(rdbRowCount);
278 EXPECT_EQ(rdbRowCount, 3);
279
280 allDataTypes->GoToFirstRow();
281
282 std::string strValue;
283 allDataTypes->GetString(1, strValue);
284 EXPECT_EQ("hello", strValue);
285
286 int intValue;
287 allDataTypes->GetInt(2, intValue);
288 EXPECT_EQ(intValue, 10);
289
290 std::vector<uint8_t> blobValue;
291 uint8_t blobData = 66;
292 allDataTypes->GetBlob(4, blobValue);
293 EXPECT_EQ(blobData, blobValue[0]);
294
295 allDataTypes->GoToNextRow();
296 allDataTypes->GetBlob(4, blobValue);
297 EXPECT_EQ(3, static_cast<int>(blobValue.size()));
298 blobData = 5;
299 EXPECT_EQ(blobData, blobValue[1]);
300 }
301
302 /* *
303 * @tc.name: Rdb_DataShare_Adapter_004
304 * @tc.desc: normal testcase of RdbDataShareAdapter
305 * @tc.type: FUNC
306 */
307 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_004, TestSize.Level1)
308 {
309 GenerateDefaultTable();
310
311 std::string table = "test";
312 OHOS::DataShare::DataSharePredicates predicates;
313 predicates.SetWhereClause("`data2` > ?");
314 predicates.SetWhereArgs(std::vector<std::string>{ "-5" });
315 predicates.SetOrder("data3");
316 std::vector<std::string> columns;
317 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
318 int rowCount;
319 allDataTypes.get()->GetRowCount(rowCount);
320 EXPECT_EQ(rowCount, 3);
321
322 allDataTypes->GoToFirstRow();
323
324 std::string strValue;
325 allDataTypes->GetString(1, strValue);
326 EXPECT_EQ("hello", strValue);
327
328 int intValue;
329 allDataTypes->GetInt(2, intValue);
330 EXPECT_EQ(intValue, 10);
331
332 std::vector<uint8_t> blobValue;
333 allDataTypes->GetBlob(4, blobValue);
334 EXPECT_EQ(1, static_cast<int>(blobValue.size()));
335
336 allDataTypes->GoToNextRow();
337
338 allDataTypes->GetString(1, strValue);
339 EXPECT_EQ("hello world", strValue);
340
341 allDataTypes->GetInt(2, intValue);
342 EXPECT_EQ(intValue, 3);
343
344 allDataTypes->GetBlob(4, blobValue);
345 EXPECT_EQ(3, static_cast<int>(blobValue.size()));
346 uint8_t blobData = 5;
347 EXPECT_EQ(blobData, blobValue[1]);
348 }
349
350 /* *
351 * @tc.name: Rdb_DataShare_Adapter_005
352 * @tc.desc: normal testcase of RdbDataShareAdapter
353 * @tc.type: FUNC
354 */
355 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_005, TestSize.Level1)
356 {
357 GenerateDefaultTable();
358 DataShareValuesBucket values;
359 int64_t id;
360 int changedRows;
361 values.Put("data1", std::string("tulip"));
362 values.Put("data2", 100);
363 values.Put("data3", 50.5);
364 values.Put("data4", std::vector<uint8_t>{ 20, 21, 22 });
365
366 int ret = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
367 EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
368 EXPECT_EQ(5, id);
369
370 std::string table = "test";
371 OHOS::DataShare::DataSharePredicates predicates;
372 std::string value = "tulip";
373 predicates.EqualTo("data1", value);
374 std::vector<std::string> columns;
375 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
376 int rowCount;
377 allDataTypes.get()->GetRowCount(rowCount);
378 EXPECT_EQ(rowCount, 1);
379
380 allDataTypes.get()->Close();
381
382 values.Clear();
383 values.Put("data3", 300.5);
384 values.Put("data4", std::vector<uint8_t>{ 17, 18, 19 });
385 ret = store->Update(
386 changedRows, "test", RdbUtils::ToValuesBucket(values), "data1 = ?", std::vector<std::string>{ "tulip" });
387 EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
388 EXPECT_EQ(1, changedRows);
389
390 allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
391 allDataTypes->GoToFirstRow();
392
393 double doubleVal;
394 allDataTypes->GetDouble(3, doubleVal);
395 EXPECT_EQ(300.5, doubleVal);
396
397 int deletedRows;
398 ret = store->Delete(deletedRows, RdbUtils::ToPredicates(predicates, table));
399 EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
400 EXPECT_EQ(1, deletedRows);
401 }
402
403 /* *
404 * @tc.name: Rdb_DataShare_Adapter_006
405 * @tc.desc: normal testcase of RdbDataShareAdapter
406 * @tc.type: FUNC
407 */
408 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_006, TestSize.Level1)
409 {
410 GenerateDefaultTable();
411
412 std::string table = "test";
413 OHOS::DataShare::DataSharePredicates predicates;
414 predicates.Limit(1, 2);
415 std::vector<std::string> columns;
416 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
417 int rdbRowCount;
418 allDataTypes.get()->GetRowCount(rdbRowCount);
419 EXPECT_EQ(rdbRowCount, 1);
420
421 allDataTypes->GoToFirstRow();
422
423 std::string strValue;
424 allDataTypes->GetString(1, strValue);
425 EXPECT_EQ("hello world", strValue);
426
427 int intValue;
428 allDataTypes->GetInt(2, intValue);
429 EXPECT_EQ(intValue, 3);
430
431 double doubleValue;
432 allDataTypes->GetDouble(3, doubleValue);
433 EXPECT_EQ(doubleValue, 1.8);
434
435 std::vector<uint8_t> blobValue;
436 uint8_t blobData1 = 4;
437 uint8_t blobData2 = 5;
438 uint8_t blobData3 = 6;
439 allDataTypes->GetBlob(4, blobValue);
440 EXPECT_EQ(3, static_cast<int>(blobValue.size()));
441 EXPECT_EQ(blobData1, blobValue[0]);
442 EXPECT_EQ(blobData2, blobValue[1]);
443 EXPECT_EQ(blobData3, blobValue[2]);
444 }
445
446 /* *
447 * @tc.name: Rdb_DataShare_Adapter_007
448 * @tc.desc: normal testcase of RdbDataShareAdapter
449 * @tc.type: FUNC
450 */
451 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_007, TestSize.Level1)
452 {
453 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,") +
454 std::string("age INTEGER, salary REAL);");
455 store->ExecuteSql(createTableSql);
456
457 DataShareValuesBucket values;
458 int64_t id;
459 values.Put("name", std::string("zhangsan"));
460 values.Put("age", INT64_MIN);
461 values.Put("salary", DBL_MIN);
462 int ret1 = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
463 EXPECT_EQ(ret1, OHOS::NativeRdb::E_OK);
464 EXPECT_EQ(1, id);
465
466 values.Clear();
467 values.Put("name", std::string("lisi"));
468 values.Put("age", INT64_MAX);
469 values.Put("salary", DBL_MAX);
470 int ret2 = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
471 EXPECT_EQ(ret2, OHOS::NativeRdb::E_OK);
472 EXPECT_EQ(2, id);
473
474 std::string table = "test";
475 OHOS::DataShare::DataSharePredicates predicates;
476 std::vector<std::string> columns;
477 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
478
479 allDataTypes->GoToFirstRow();
480 int64_t int64Value;
481 allDataTypes->GetLong(2, int64Value);
482 EXPECT_EQ(int64Value, INT64_MIN);
483
484 double doubleVal;
485 allDataTypes->GetDouble(3, doubleVal);
486 EXPECT_EQ(doubleVal, DBL_MIN);
487
488 allDataTypes->GoToNextRow();
489
490 allDataTypes->GetLong(2, int64Value);
491 EXPECT_EQ(int64Value, INT64_MAX);
492
493 allDataTypes->GetDouble(3, doubleVal);
494 EXPECT_EQ(doubleVal, DBL_MAX);
495 }
496
497 /* *
498 * @tc.name: Rdb_DataShare_Adapter_008
499 * @tc.desc: normal testcase of query double
500 * @tc.type: test double for high accuracy
501 */
502 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_008, TestSize.Level1)
503 {
504 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 double,") +
505 std::string("data2 double, data3 TEXT);");
506 store->ExecuteSql(createTableSql);
507
508 ValuesBucket values;
509 int64_t id;
510 double data1 = 1.777777777777;
511 double data2 = 1.888888888888;
512 std::string data3 = "zh-has";
513 std::string tableName = "test";
514
515 values.PutDouble("data1", data1);
516 values.PutDouble("data2", data2);
517 values.PutString("data3", data3);
518 int ret = store->Insert(id, tableName, values);
519 EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
520 EXPECT_EQ(1, id);
521
522 OHOS::DataShare::DataSharePredicates predicates;
523 predicates.BeginWrap()
524 ->EqualTo("data1", data1)
525 ->And()
526 ->EqualTo("data2", data2)
527 ->And()
528 ->EqualTo("data3", data3)
529 ->EndWrap();
530 std::vector<std::string> columns;
531 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, tableName), columns);
532 int rowCount;
533 int ok = allDataTypes->GetRowCount(rowCount);
534 EXPECT_EQ(ok, OHOS::NativeRdb::E_OK);
535 EXPECT_EQ(1, rowCount);
536 }
537
538 /* *
539 * @tc.name: Rdb_DataShare_Adapter_009
540 * @tc.desc: normal testcase of RdbDataShareAdapter
541 * @tc.type: FUNC
542 */
543 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_009, TestSize.Level1)
544 {
545 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,") +
546 std::string("age INTEGER, salary REAL);");
547 store->ExecuteSql(createTableSql);
548
549 DataShareValuesBucket values;
550 int64_t id;
551 values.Put("name", std::string("zhangsan"));
552 values.Put("age", INT64_MIN);
553 values.Put("salary", DBL_MIN);
554 int ret1 = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
555 EXPECT_EQ(ret1, OHOS::NativeRdb::E_OK);
556 EXPECT_EQ(1, id);
557
558 values.Clear();
559 values.Put("name", std::string("lisi"));
560 values.Put("age", INT64_MAX);
561 values.Put("salary", DBL_MAX);
562 int ret2 = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
563 EXPECT_EQ(ret2, OHOS::NativeRdb::E_OK);
564 EXPECT_EQ(2, id);
565
566 std::string table = "test";
567 OHOS::DataShare::OperationItem item;
568 item.singleParams = {};
569 RdbPredicates predicates("test");
570 RdbUtils::EqualTo(item, predicates);
571 std::vector<std::string> columns;
572 std::shared_ptr<ResultSet> allPerson = store->Query(predicates, columns);
573 EXPECT_EQ(2, ResultSize(allPerson));
574
575 RdbUtils::GreaterThan(item, predicates);
576 allPerson = store->Query(predicates, columns);
577 EXPECT_EQ(2, ResultSize(allPerson));
578
579 RdbUtils::Limit(item, predicates);
580 allPerson = store->Query(predicates, columns);
581 EXPECT_EQ(2, ResultSize(allPerson));
582
583 RdbUtils::NotEqualTo(item, predicates);
584 allPerson = store->Query(predicates, columns);
585 EXPECT_EQ(2, ResultSize(allPerson));
586
587 RdbUtils::LessThan(item, predicates);
588 allPerson = store->Query(predicates, columns);
589 EXPECT_EQ(2, ResultSize(allPerson));
590 }
591
592 /* *
593 * @tc.name: Rdb_DataShare_Adapter_010
594 * @tc.desc: normal testcase of RdbDataShareAdapter
595 * @tc.type: FUNC
596 */
597 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_010, TestSize.Level1)
598 {
599 GenerateDefaultTable();
600
601 std::string table = "test";
602 std::string column = "data1";
603 std::string value = "%hello%";
604 DataSharePredicates predicates;
605 predicates.Unlike(column, value);
606 std::vector<std::string> columns;
607 auto result = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
608 int rowCount = 0;
609 if (result.get() != nullptr) {
610 result.get()->GetRowCount(rowCount);
611 }
612 EXPECT_EQ(rowCount, 2);
613 }
614
LessThanTest(MockRdbPredicates & predicates)615 void RdbDataShareAdapterTest::LessThanTest(MockRdbPredicates &predicates)
616 {
617 EXPECT_CALL(predicates, LessThan(testing::_, testing::_)).Times(1);
618 auto item = CreateOperationItem(0, { "name", "John" });
619 RdbUtils::LessThan(item, predicates);
620 }
621
GreaterThanOrEqualTo(MockRdbPredicates & predicates)622 void RdbDataShareAdapterTest::GreaterThanOrEqualTo(MockRdbPredicates &predicates)
623 {
624 EXPECT_CALL(predicates, GreaterThanOrEqualTo(testing::_, testing::_)).Times(1);
625 auto item1 = CreateOperationItem(0, { "John" });
626 auto item2 = CreateOperationItem(0, { "name", "John" });
627 RdbUtils::GreaterThanOrEqualTo(item1, predicates);
628 RdbUtils::GreaterThanOrEqualTo(item2, predicates);
629 }
630
LessThanOrEqualTo(MockRdbPredicates & predicates)631 void RdbDataShareAdapterTest::LessThanOrEqualTo(MockRdbPredicates &predicates)
632 {
633 EXPECT_CALL(predicates, LessThanOrEqualTo(testing::_, testing::_)).Times(1);
634 auto item1 = CreateOperationItem(0, { "John" });
635 auto item2 = CreateOperationItem(0, { "name", "John" });
636 RdbUtils::LessThanOrEqualTo(item1, predicates);
637 RdbUtils::LessThanOrEqualTo(item2, predicates);
638 }
639
IsNull(MockRdbPredicates & predicates)640 void RdbDataShareAdapterTest::IsNull(MockRdbPredicates &predicates)
641 {
642 EXPECT_CALL(predicates, IsNull(testing::_)).Times(1);
643 auto item1 = CreateOperationItem(0, {});
644 auto item2 = CreateOperationItem(0, { "name", "John" });
645 RdbUtils::IsNull(item1, predicates);
646 RdbUtils::IsNull(item2, predicates);
647 }
648
IsNotNull(MockRdbPredicates & predicates)649 void RdbDataShareAdapterTest::IsNotNull(MockRdbPredicates &predicates)
650 {
651 EXPECT_CALL(predicates, IsNotNull(testing::_)).Times(1);
652 auto item1 = CreateOperationItem(0, {});
653 auto item2 = CreateOperationItem(0, { "name", "John" });
654 RdbUtils::IsNotNull(item1, predicates);
655 RdbUtils::IsNotNull(item2, predicates);
656 }
657
In(MockRdbPredicates & predicates)658 void RdbDataShareAdapterTest::In(MockRdbPredicates &predicates)
659 {
660 EXPECT_CALL(predicates, In(testing::_, testing::_)).Times(1);
661 auto item1 = CreateOperationItem(0);
662 auto item2 = CreateOperationItem(0, { "test_table", "John" });
663 auto item3 = CreateOperationItem(0, {}, { std::vector<std::string>{ "zhangSan" }, std::vector<int>{ 1, 2, 3 } });
664 auto item4 = CreateOperationItem(
665 0, { "test_table", 2 }, { std::vector<std::string>{ "zhangSan" }, std::vector<int>{ 1, 2, 3 } });
666 RdbUtils::In(item1, predicates);
667 RdbUtils::In(item2, predicates);
668 RdbUtils::In(item3, predicates);
669 RdbUtils::In(item4, predicates);
670 }
671
NotIn(MockRdbPredicates & predicates)672 void RdbDataShareAdapterTest::NotIn(MockRdbPredicates &predicates)
673 {
674 EXPECT_CALL(predicates, NotIn(testing::_, testing::_)).Times(1);
675 auto item1 = CreateOperationItem(0);
676 auto item2 = CreateOperationItem(0, { "test_table", "John" });
677 auto item3 = CreateOperationItem(0, {}, { std::vector<std::string>{ "zhangSan" }, std::vector<int>{ 1, 2, 3 } });
678 auto item4 = CreateOperationItem(
679 0, { "test_table", 2 }, { std::vector<std::string>{ "zhangSan" }, std::vector<int>{ 1, 2, 3 } });
680 RdbUtils::NotIn(item1, predicates);
681 RdbUtils::NotIn(item2, predicates);
682 RdbUtils::NotIn(item3, predicates);
683 RdbUtils::NotIn(item4, predicates);
684 }
685
Like(MockRdbPredicates & predicates)686 void RdbDataShareAdapterTest::Like(MockRdbPredicates &predicates)
687 {
688 EXPECT_CALL(predicates, Like(testing::_, testing::_)).Times(1);
689 auto item1 = CreateOperationItem(0, {});
690 auto item2 = CreateOperationItem(0, { "name", "John" });
691 RdbUtils::Like(item1, predicates);
692 RdbUtils::Like(item2, predicates);
693 }
694
NotLike(MockRdbPredicates & predicates)695 void RdbDataShareAdapterTest::NotLike(MockRdbPredicates &predicates)
696 {
697 EXPECT_CALL(predicates, NotLike(testing::_, testing::_)).Times(1);
698 auto item1 = CreateOperationItem(0, {});
699 auto item2 = CreateOperationItem(0, { "name", "John" });
700 RdbUtils::NotLike(item1, predicates);
701 RdbUtils::NotLike(item2, predicates);
702 }
703
OrderByAsc(MockRdbPredicates & predicates)704 void RdbDataShareAdapterTest::OrderByAsc(MockRdbPredicates &predicates)
705 {
706 EXPECT_CALL(predicates, OrderByAsc(testing::_)).Times(1);
707 auto item1 = CreateOperationItem(0, {});
708 auto item2 = CreateOperationItem(0, { "name", "John" });
709 RdbUtils::OrderByAsc(item1, predicates);
710 RdbUtils::OrderByAsc(item2, predicates);
711 }
712
OrderByDesc(MockRdbPredicates & predicates)713 void RdbDataShareAdapterTest::OrderByDesc(MockRdbPredicates &predicates)
714 {
715 EXPECT_CALL(predicates, OrderByDesc(testing::_)).Times(1);
716 auto item1 = CreateOperationItem(0, {});
717 auto item2 = CreateOperationItem(0, { "name", "John" });
718 RdbUtils::OrderByDesc(item1, predicates);
719 RdbUtils::OrderByDesc(item2, predicates);
720 }
721
Offset(MockRdbPredicates & predicates)722 void RdbDataShareAdapterTest::Offset(MockRdbPredicates &predicates)
723 {
724 EXPECT_CALL(predicates, Offset(testing::_)).Times(1);
725 auto item1 = CreateOperationItem(0, {});
726 auto item2 = CreateOperationItem(0, { "name", "John" });
727 RdbUtils::Offset(item1, predicates);
728 RdbUtils::Offset(item2, predicates);
729 }
730
BeginsWith(MockRdbPredicates & predicates)731 void RdbDataShareAdapterTest::BeginsWith(MockRdbPredicates &predicates)
732 {
733 EXPECT_CALL(predicates, BeginsWith(testing::_, testing::_)).Times(1);
734 auto item1 = CreateOperationItem(0, {});
735 auto item2 = CreateOperationItem(0, { "name", "John" });
736 RdbUtils::BeginsWith(item1, predicates);
737 RdbUtils::BeginsWith(item2, predicates);
738 }
739
EndsWith(MockRdbPredicates & predicates)740 void RdbDataShareAdapterTest::EndsWith(MockRdbPredicates &predicates)
741 {
742 EXPECT_CALL(predicates, EndsWith(testing::_, testing::_)).Times(1);
743 auto item1 = CreateOperationItem(0, {});
744 auto item2 = CreateOperationItem(0, { "name", "John" });
745 RdbUtils::EndsWith(item1, predicates);
746 RdbUtils::EndsWith(item2, predicates);
747 }
748
GroupBy(MockRdbPredicates & predicates)749 void RdbDataShareAdapterTest::GroupBy(MockRdbPredicates &predicates)
750 {
751 EXPECT_CALL(predicates, GroupBy(testing::_)).Times(1);
752 auto item1 = CreateOperationItem(0);
753 auto item2 = CreateOperationItem(0, {}, { std::vector<std::string>{ "zhangSan" }, std::vector<int>{ 1, 2, 3 } });
754 RdbUtils::GroupBy(item1, predicates);
755 RdbUtils::GroupBy(item2, predicates);
756 }
757
IndexedBy(MockRdbPredicates & predicates)758 void RdbDataShareAdapterTest::IndexedBy(MockRdbPredicates &predicates)
759 {
760 EXPECT_CALL(predicates, IndexedBy(testing::_)).Times(1);
761 auto item1 = CreateOperationItem(0, {});
762 auto item2 = CreateOperationItem(0, { "name", "John" });
763 RdbUtils::IndexedBy(item1, predicates);
764 RdbUtils::IndexedBy(item2, predicates);
765 }
766
Contains(MockRdbPredicates & predicates)767 void RdbDataShareAdapterTest::Contains(MockRdbPredicates &predicates)
768 {
769 EXPECT_CALL(predicates, Contains(testing::_, testing::_)).Times(1);
770 auto item1 = CreateOperationItem(0, {});
771 auto item2 = CreateOperationItem(0, { "name", "John" });
772 RdbUtils::Contains(item1, predicates);
773 RdbUtils::Contains(item2, predicates);
774 }
775
NotContains(MockRdbPredicates & predicates)776 void RdbDataShareAdapterTest::NotContains(MockRdbPredicates &predicates)
777 {
778 EXPECT_CALL(predicates, NotContains(testing::_, testing::_)).Times(1);
779 auto item1 = CreateOperationItem(0, {});
780 auto item2 = CreateOperationItem(0, { "name", "John" });
781 RdbUtils::NotContains(item1, predicates);
782 RdbUtils::NotContains(item2, predicates);
783 }
784
Glob(MockRdbPredicates & predicates)785 void RdbDataShareAdapterTest::Glob(MockRdbPredicates &predicates)
786 {
787 EXPECT_CALL(predicates, Glob(testing::_, testing::_)).Times(1);
788 auto item1 = CreateOperationItem(0, {});
789 auto item2 = CreateOperationItem(0, { "name", "John" });
790 RdbUtils::Glob(item1, predicates);
791 RdbUtils::Glob(item2, predicates);
792 }
793
Between(MockRdbPredicates & predicates)794 void RdbDataShareAdapterTest::Between(MockRdbPredicates &predicates)
795 {
796 EXPECT_CALL(predicates, Between(testing::_, testing::_, testing::_)).Times(1);
797 auto item1 = CreateOperationItem(0, {});
798 auto item2 = CreateOperationItem(0, { "name", 1, true });
799 RdbUtils::Between(item1, predicates);
800 RdbUtils::Between(item2, predicates);
801 }
802
NotBetween(MockRdbPredicates & predicates)803 void RdbDataShareAdapterTest::NotBetween(MockRdbPredicates &predicates)
804 {
805 EXPECT_CALL(predicates, NotBetween(testing::_, testing::_, testing::_)).Times(1);
806 auto item1 = CreateOperationItem(0, {});
807 auto item2 = CreateOperationItem(0, { "name", 1, true });
808 RdbUtils::NotBetween(item1, predicates);
809 RdbUtils::NotBetween(item2, predicates);
810 }
811
812 /**
813 * @tc.name: RdbUtils_Operation_Test
814 * @tc.desc: Test all operation handlers in RdbUtils
815 * @tc.type: FUNC
816 */
817 HWTEST_F(RdbDataShareAdapterTest, RdbUtils_Operation_Test, TestSize.Level1)
818 {
819 LOG_INFO("RdbUtils_Operation_Test start");
820 MockRdbPredicates predicates("test_table");
821 LessThanTest(predicates);
822 GreaterThanOrEqualTo(predicates);
823 LessThanOrEqualTo(predicates);
824 IsNull(predicates);
825 IsNotNull(predicates);
826 In(predicates);
827 NotIn(predicates);
828 Like(predicates);
829 NotLike(predicates);
830 OrderByAsc(predicates);
831 OrderByDesc(predicates);
832 Offset(predicates);
833 BeginsWith(predicates);
834 EndsWith(predicates);
835 GroupBy(predicates);
836 IndexedBy(predicates);
837 Contains(predicates);
838 NotContains(predicates);
839 Glob(predicates);
840 Between(predicates);
841 NotBetween(predicates);
842 }
843