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