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 <gtest/gtest.h>
17
18 #include <string>
19
20 #include "datashare_predicates.h"
21 #include "logger.h"
22 #include "rdb_errno.h"
23 #include "rdb_helper.h"
24 #include "rdb_open_callback.h"
25 #include "rdb_utils.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::Rdb;
29 using namespace OHOS::NativeRdb;
30 using namespace OHOS::DataShare;
31 using namespace OHOS::RdbDataShareAdapter;
32
33 class RdbDataShareAdapterTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36
37 static void TearDownTestCase(void);
38
39 void SetUp();
40
41 void TearDown();
42
43 void GenerateDefaultTable();
44
45 void GenerateDefaultEmptyTable();
46
47 int ResultSize(std::shared_ptr<ResultSet> resultSet);
48
49 static const std::string DATABASE_NAME;
50 static std::shared_ptr<RdbStore> store;
51 static const std::string RDB_ADAPTER_TEST_PATH;
52 };
53
54 const std::string RdbDataShareAdapterTest::RDB_ADAPTER_TEST_PATH = "/data/test/";
55 const std::string RdbDataShareAdapterTest::DATABASE_NAME = RDB_ADAPTER_TEST_PATH + "rdbDataShareAdapter_test.db";
56 std::shared_ptr<RdbStore> RdbDataShareAdapterTest::store = nullptr;
57
58 class RdbStepSharedResultSetOpenCallback : public RdbOpenCallback {
59 public:
60 int OnCreate(RdbStore &store) override;
61
62 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
63
64 static const std::string CREATE_TABLE_TEST;
65 };
66
OnCreate(RdbStore & store)67 int RdbStepSharedResultSetOpenCallback::OnCreate(RdbStore &store)
68 {
69 return OHOS::NativeRdb::E_OK;
70 }
71
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)72 int RdbStepSharedResultSetOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
73 {
74 return OHOS::NativeRdb::E_OK;
75 }
76
SetUpTestCase(void)77 void RdbDataShareAdapterTest::SetUpTestCase(void)
78 {
79 int errCode = OHOS::NativeRdb::E_OK;
80 RdbStoreConfig config(RdbDataShareAdapterTest::DATABASE_NAME);
81 RdbStepSharedResultSetOpenCallback helper;
82 RdbDataShareAdapterTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
83 EXPECT_NE(RdbDataShareAdapterTest::store, nullptr);
84 EXPECT_EQ(errCode, OHOS::NativeRdb::E_OK);
85 }
86
TearDownTestCase(void)87 void RdbDataShareAdapterTest::TearDownTestCase(void)
88 {
89 RdbHelper::DeleteRdbStore(RdbDataShareAdapterTest::DATABASE_NAME);
90 }
91
SetUp(void)92 void RdbDataShareAdapterTest::SetUp(void)
93 {
94 store->ExecuteSql("DROP TABLE IF EXISTS test");
95 }
96
TearDown(void)97 void RdbDataShareAdapterTest::TearDown(void)
98 {
99 RdbHelper::ClearCache();
100 }
101
GenerateDefaultTable()102 void RdbDataShareAdapterTest::GenerateDefaultTable()
103 {
104 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
105 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
106 store->ExecuteSql(createTableSql);
107
108 std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
109
110 /* insert first entry data */
111 uint8_t uValue = 66;
112 std::vector<uint8_t> typeBlob;
113 typeBlob.push_back(uValue);
114 store->ExecuteSql(insertSql, std::vector<ValueObject>{ ValueObject(std::string("hello")), ValueObject((int)10),
115 ValueObject((double)1.0), ValueObject((std::vector<uint8_t>)typeBlob) });
116
117 /* insert second entry data */
118 typeBlob.clear();
119 store->ExecuteSql(insertSql, std::vector<ValueObject>{
120 ValueObject(std::string("2")), ValueObject((int)-5), ValueObject((double)2.5),
121 ValueObject() // set double value 2.5
122 });
123
124 /* insert third entry data */
125 store->ExecuteSql(insertSql, std::vector<ValueObject>{
126 ValueObject(std::string("hello world")), ValueObject((int)3), ValueObject((double)1.8),
127 ValueObject(std::vector<uint8_t>{ 4, 5, 6 }) // set int value 3, double 1.8
128 });
129
130 /* insert four entry data */
131 store->ExecuteSql(insertSql, std::vector<ValueObject>{
132 ValueObject(std::string("new world")), ValueObject((int)5),
133 ValueObject((double)5.8), ValueObject() // set int value 5, double 5.8
134 });
135 }
136
GenerateDefaultEmptyTable()137 void RdbDataShareAdapterTest::GenerateDefaultEmptyTable()
138 {
139 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
140 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
141 store->ExecuteSql(createTableSql);
142 }
143
ResultSize(std::shared_ptr<ResultSet> resultSet)144 int RdbDataShareAdapterTest::ResultSize(std::shared_ptr<ResultSet> resultSet)
145 {
146 if (resultSet->GoToFirstRow() != OHOS::NativeRdb::E_OK) {
147 return 0;
148 }
149 int count = 1;
150 while (resultSet->GoToNextRow() == OHOS::NativeRdb::E_OK) {
151 count++;
152 }
153 return count;
154 }
155
156 /* *
157 * @tc.name: Rdb_DataShare_Adapter_001
158 * @tc.desc: test RdbDataShareAdapter
159 * @tc.type: FUNC
160 */
161 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_001, TestSize.Level1)
162 {
163 GenerateDefaultTable();
164
165 std::shared_ptr<OHOS::NativeRdb::ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
166 EXPECT_NE(resultSet, nullptr);
167 int rowCount;
168 resultSet.get()->GetRowCount(rowCount);
169 LOG_INFO("result row count: %{public}d", rowCount);
170 EXPECT_NE(rowCount, 0);
171 auto bridge = OHOS::RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
172 EXPECT_NE(bridge, nullptr);
173 }
174
175 /* *
176 * @tc.name: Rdb_DataShare_Adapter_002
177 * @tc.desc: normal testcase of RdbDataShareAdapter
178 * @tc.type: FUNC
179 */
180 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_002, TestSize.Level1)
181 {
182 GenerateDefaultTable();
183
184 std::string table = "test";
185 std::string column = "data1";
186 std::string value = "hello";
187 DataSharePredicates predicates;
188 predicates.EqualTo(column, value);
189 std::vector<std::string> columns;
190 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
191 int rowCount;
192 allDataTypes.get()->GetRowCount(rowCount);
193 EXPECT_EQ(rowCount, 1);
194 }
195
196 /* *
197 * @tc.name: Rdb_DataShare_Adapter_003
198 * @tc.desc: normal testcase of RdbDataShareAdapter
199 * @tc.type: FUNC
200 */
201 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_003, TestSize.Level1)
202 {
203 GenerateDefaultTable();
204
205 std::string table = "test";
206 OHOS::DataShare::DataSharePredicates predicates;
207 predicates.GreaterThan("data2", -5);
208 std::vector<std::string> columns;
209 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
210 int rdbRowCount;
211 allDataTypes.get()->GetRowCount(rdbRowCount);
212 EXPECT_EQ(rdbRowCount, 3);
213
214 allDataTypes->GoToFirstRow();
215
216 std::string strValue;
217 allDataTypes->GetString(1, strValue);
218 EXPECT_EQ("hello", strValue);
219
220 int intValue;
221 allDataTypes->GetInt(2, intValue);
222 EXPECT_EQ(intValue, 10);
223
224 std::vector<uint8_t> blobValue;
225 uint8_t blobData = 66;
226 allDataTypes->GetBlob(4, blobValue);
227 EXPECT_EQ(blobData, blobValue[0]);
228
229 allDataTypes->GoToNextRow();
230 allDataTypes->GetBlob(4, blobValue);
231 EXPECT_EQ(3, static_cast<int>(blobValue.size()));
232 blobData = 5;
233 EXPECT_EQ(blobData, blobValue[1]);
234 }
235
236 /* *
237 * @tc.name: Rdb_DataShare_Adapter_004
238 * @tc.desc: normal testcase of RdbDataShareAdapter
239 * @tc.type: FUNC
240 */
241 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_004, TestSize.Level1)
242 {
243 GenerateDefaultTable();
244
245 std::string table = "test";
246 OHOS::DataShare::DataSharePredicates predicates;
247 predicates.SetWhereClause("`data2` > ?");
248 predicates.SetWhereArgs(std::vector<std::string>{ "-5" });
249 predicates.SetOrder("data3");
250 std::vector<std::string> columns;
251 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
252 int rowCount;
253 allDataTypes.get()->GetRowCount(rowCount);
254 EXPECT_EQ(rowCount, 3);
255
256 allDataTypes->GoToFirstRow();
257
258 std::string strValue;
259 allDataTypes->GetString(1, strValue);
260 EXPECT_EQ("hello", strValue);
261
262 int intValue;
263 allDataTypes->GetInt(2, intValue);
264 EXPECT_EQ(intValue, 10);
265
266 std::vector<uint8_t> blobValue;
267 allDataTypes->GetBlob(4, blobValue);
268 EXPECT_EQ(1, static_cast<int>(blobValue.size()));
269
270 allDataTypes->GoToNextRow();
271
272 allDataTypes->GetString(1, strValue);
273 EXPECT_EQ("hello world", strValue);
274
275 allDataTypes->GetInt(2, intValue);
276 EXPECT_EQ(intValue, 3);
277
278 allDataTypes->GetBlob(4, blobValue);
279 EXPECT_EQ(3, static_cast<int>(blobValue.size()));
280 uint8_t blobData = 5;
281 EXPECT_EQ(blobData, blobValue[1]);
282 }
283
284 /* *
285 * @tc.name: Rdb_DataShare_Adapter_005
286 * @tc.desc: normal testcase of RdbDataShareAdapter
287 * @tc.type: FUNC
288 */
289 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_005, TestSize.Level1)
290 {
291 GenerateDefaultTable();
292 DataShareValuesBucket values;
293 int64_t id;
294 int changedRows;
295 values.Put("data1", std::string("tulip"));
296 values.Put("data2", 100);
297 values.Put("data3", 50.5);
298 values.Put("data4", std::vector<uint8_t>{ 20, 21, 22 });
299
300 int ret = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
301 EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
302 EXPECT_EQ(5, id);
303
304 std::string table = "test";
305 OHOS::DataShare::DataSharePredicates predicates;
306 std::string value = "tulip";
307 predicates.EqualTo("data1", value);
308 std::vector<std::string> columns;
309 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
310 int rowCount;
311 allDataTypes.get()->GetRowCount(rowCount);
312 EXPECT_EQ(rowCount, 1);
313
314 allDataTypes.get()->Close();
315
316 values.Clear();
317 values.Put("data3", 300.5);
318 values.Put("data4", std::vector<uint8_t>{ 17, 18, 19 });
319 ret = store->Update(
320 changedRows, "test", RdbUtils::ToValuesBucket(values), "data1 = ?", std::vector<std::string>{ "tulip" });
321 EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
322 EXPECT_EQ(1, changedRows);
323
324 allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
325 allDataTypes->GoToFirstRow();
326
327 double doubleVal;
328 allDataTypes->GetDouble(3, doubleVal);
329 EXPECT_EQ(300.5, doubleVal);
330
331 int deletedRows;
332 ret = store->Delete(deletedRows, RdbUtils::ToPredicates(predicates, table));
333 EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
334 EXPECT_EQ(1, deletedRows);
335 }
336
337 /* *
338 * @tc.name: Rdb_DataShare_Adapter_006
339 * @tc.desc: normal testcase of RdbDataShareAdapter
340 * @tc.type: FUNC
341 */
342 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_006, TestSize.Level1)
343 {
344 GenerateDefaultTable();
345
346 std::string table = "test";
347 OHOS::DataShare::DataSharePredicates predicates;
348 predicates.Limit(1, 2);
349 std::vector<std::string> columns;
350 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
351 int rdbRowCount;
352 allDataTypes.get()->GetRowCount(rdbRowCount);
353 EXPECT_EQ(rdbRowCount, 1);
354
355 allDataTypes->GoToFirstRow();
356
357 std::string strValue;
358 allDataTypes->GetString(1, strValue);
359 EXPECT_EQ("hello world", strValue);
360
361 int intValue;
362 allDataTypes->GetInt(2, intValue);
363 EXPECT_EQ(intValue, 3);
364
365 double doubleValue;
366 allDataTypes->GetDouble(3, doubleValue);
367 EXPECT_EQ(doubleValue, 1.8);
368
369 std::vector<uint8_t> blobValue;
370 uint8_t blobData1 = 4;
371 uint8_t blobData2 = 5;
372 uint8_t blobData3 = 6;
373 allDataTypes->GetBlob(4, blobValue);
374 EXPECT_EQ(3, static_cast<int>(blobValue.size()));
375 EXPECT_EQ(blobData1, blobValue[0]);
376 EXPECT_EQ(blobData2, blobValue[1]);
377 EXPECT_EQ(blobData3, blobValue[2]);
378 }
379
380 /* *
381 * @tc.name: Rdb_DataShare_Adapter_007
382 * @tc.desc: normal testcase of RdbDataShareAdapter
383 * @tc.type: FUNC
384 */
385 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_007, TestSize.Level1)
386 {
387 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,") +
388 std::string("age INTEGER, salary REAL);");
389 store->ExecuteSql(createTableSql);
390
391 DataShareValuesBucket values;
392 int64_t id;
393 values.Put("name", std::string("zhangsan"));
394 values.Put("age", INT64_MIN);
395 values.Put("salary", DBL_MIN);
396 int ret1 = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
397 EXPECT_EQ(ret1, OHOS::NativeRdb::E_OK);
398 EXPECT_EQ(1, id);
399
400 values.Clear();
401 values.Put("name", std::string("lisi"));
402 values.Put("age", INT64_MAX);
403 values.Put("salary", DBL_MAX);
404 int ret2 = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
405 EXPECT_EQ(ret2, OHOS::NativeRdb::E_OK);
406 EXPECT_EQ(2, id);
407
408 std::string table = "test";
409 OHOS::DataShare::DataSharePredicates predicates;
410 std::vector<std::string> columns;
411 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
412
413 allDataTypes->GoToFirstRow();
414 int64_t int64Value;
415 allDataTypes->GetLong(2, int64Value);
416 EXPECT_EQ(int64Value, INT64_MIN);
417
418 double doubleVal;
419 allDataTypes->GetDouble(3, doubleVal);
420 EXPECT_EQ(doubleVal, DBL_MIN);
421
422 allDataTypes->GoToNextRow();
423
424 allDataTypes->GetLong(2, int64Value);
425 EXPECT_EQ(int64Value, INT64_MAX);
426
427 allDataTypes->GetDouble(3, doubleVal);
428 EXPECT_EQ(doubleVal, DBL_MAX);
429 }
430
431 /* *
432 * @tc.name: Rdb_DataShare_Adapter_008
433 * @tc.desc: normal testcase of query double
434 * @tc.type: test double for high accuracy
435 */
436 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_008, TestSize.Level1)
437 {
438 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 double,") +
439 std::string("data2 double, data3 TEXT);");
440 store->ExecuteSql(createTableSql);
441
442 ValuesBucket values;
443 int64_t id;
444 double data1 = 1.777777777777;
445 double data2 = 1.888888888888;
446 std::string data3 = "zh-has";
447 std::string tableName = "test";
448
449 values.PutDouble("data1", data1);
450 values.PutDouble("data2", data2);
451 values.PutString("data3", data3);
452 int ret = store->Insert(id, tableName, values);
453 EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
454 EXPECT_EQ(1, id);
455
456 OHOS::DataShare::DataSharePredicates predicates;
457 predicates.BeginWrap()
458 ->EqualTo("data1", data1)
459 ->And()
460 ->EqualTo("data2", data2)
461 ->And()
462 ->EqualTo("data3", data3)
463 ->EndWrap();
464 std::vector<std::string> columns;
465 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, tableName), columns);
466 int rowCount;
467 int ok = allDataTypes->GetRowCount(rowCount);
468 EXPECT_EQ(ok, OHOS::NativeRdb::E_OK);
469 EXPECT_EQ(1, rowCount);
470 }
471
472 /* *
473 * @tc.name: Rdb_DataShare_Adapter_009
474 * @tc.desc: normal testcase of RdbDataShareAdapter
475 * @tc.type: FUNC
476 */
477 HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_009, TestSize.Level1)
478 {
479 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT,") +
480 std::string("age INTEGER, salary REAL);");
481 store->ExecuteSql(createTableSql);
482
483 DataShareValuesBucket values;
484 int64_t id;
485 values.Put("name", std::string("zhangsan"));
486 values.Put("age", INT64_MIN);
487 values.Put("salary", DBL_MIN);
488 int ret1 = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
489 EXPECT_EQ(ret1, OHOS::NativeRdb::E_OK);
490 EXPECT_EQ(1, id);
491
492 values.Clear();
493 values.Put("name", std::string("lisi"));
494 values.Put("age", INT64_MAX);
495 values.Put("salary", DBL_MAX);
496 int ret2 = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
497 EXPECT_EQ(ret2, OHOS::NativeRdb::E_OK);
498 EXPECT_EQ(2, id);
499
500 std::string table = "test";
501 OHOS::DataShare::OperationItem item;
502 item.singleParams = {};
503 RdbPredicates predicates("test");
504 RdbUtils::EqualTo(item, predicates);
505 std::vector<std::string> columns;
506 std::shared_ptr<ResultSet> allPerson = store->Query(predicates, columns);
507 EXPECT_EQ(2, ResultSize(allPerson));
508
509 RdbUtils::GreaterThan(item, predicates);
510 allPerson = store->Query(predicates, columns);
511 EXPECT_EQ(2, ResultSize(allPerson));
512
513 RdbUtils::Limit(item, predicates);
514 allPerson = store->Query(predicates, columns);
515 EXPECT_EQ(2, ResultSize(allPerson));
516
517 RdbUtils::NotEqualTo(item, predicates);
518 allPerson = store->Query(predicates, columns);
519 EXPECT_EQ(2, ResultSize(allPerson));
520
521 RdbUtils::LessThan(item, predicates);
522 allPerson = store->Query(predicates, columns);
523 EXPECT_EQ(2, ResultSize(allPerson));
524 }
525