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
16 #include <gtest/gtest.h>
17 #include <string>
18
19 #include "datashare_predicates.h"
20 #include "logger.h"
21 #include "rdb_errno.h"
22 #include "rdb_helper.h"
23 #include "rdb_open_callback.h"
24 #include "rdb_utils.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::Rdb;
28 using namespace OHOS::NativeRdb;
29 using namespace OHOS::DataShare;
30 using namespace OHOS::RdbDataShareAdapter;
31
32 class RdbDataShareAdapterTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35
36 static void TearDownTestCase(void);
37
38 void SetUp();
39
40 void TearDown();
41
42 void GenerateDefaultTable();
43
44 void GenerateDefaultEmptyTable();
45
46 static const std::string DATABASE_NAME;
47 static std::shared_ptr<RdbStore> store;
48 static const std::string RDB_ADAPTER_TEST_PATH;
49 };
50
51 const std::string RdbDataShareAdapterTest::RDB_ADAPTER_TEST_PATH = "/data/test/";
52 const std::string RdbDataShareAdapterTest::DATABASE_NAME = RDB_ADAPTER_TEST_PATH + "rdbDataShareAdapter_test.db";
53 std::shared_ptr<RdbStore> RdbDataShareAdapterTest::store = nullptr;
54
55 class RdbStepSharedResultSetOpenCallback : public RdbOpenCallback {
56 public:
57 int OnCreate(RdbStore &store) override;
58
59 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
60
61 static const std::string CREATE_TABLE_TEST;
62 };
63
OnCreate(RdbStore & store)64 int RdbStepSharedResultSetOpenCallback::OnCreate(RdbStore &store)
65 {
66 return OHOS::NativeRdb::E_OK;
67 }
68
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)69 int RdbStepSharedResultSetOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
70 {
71 return OHOS::NativeRdb::E_OK;
72 }
73
SetUpTestCase(void)74 void RdbDataShareAdapterTest::SetUpTestCase(void)
75 {
76 int errCode = OHOS::NativeRdb::E_OK;
77 RdbStoreConfig config(RdbDataShareAdapterTest::DATABASE_NAME);
78 RdbStepSharedResultSetOpenCallback helper;
79 RdbDataShareAdapterTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
80 EXPECT_NE(RdbDataShareAdapterTest::store, nullptr);
81 EXPECT_EQ(errCode, OHOS::NativeRdb::E_OK);
82 }
83
TearDownTestCase(void)84 void RdbDataShareAdapterTest::TearDownTestCase(void)
85 {
86 RdbHelper::DeleteRdbStore(RdbDataShareAdapterTest::DATABASE_NAME);
87 }
88
SetUp(void)89 void RdbDataShareAdapterTest::SetUp(void)
90 {
91 store->ExecuteSql("DROP TABLE IF EXISTS test");
92 }
93
TearDown(void)94 void RdbDataShareAdapterTest::TearDown(void)
95 {
96 RdbHelper::ClearCache();
97 }
98
GenerateDefaultTable()99 void RdbDataShareAdapterTest::GenerateDefaultTable()
100 {
101 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
102 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
103 store->ExecuteSql(createTableSql);
104
105 std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
106
107 /* insert first entry data */
108 uint8_t uValue = 66;
109 std::vector<uint8_t> typeBlob;
110 typeBlob.push_back(uValue);
111 store->ExecuteSql(insertSql, std::vector<ValueObject> {
112 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
396 std::string table = "test";
397 OHOS::DataShare::DataSharePredicates predicates;
398 std::vector<std::string> columns;
399 auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
400
401 allDataTypes->GoToFirstRow();
402 int64_t int64Value;
403 allDataTypes->GetLong(2, int64Value);
404 EXPECT_EQ(int64Value, INT64_MIN);
405
406 double doubleVal;
407 allDataTypes->GetDouble(3, doubleVal);
408 EXPECT_EQ(doubleVal, DBL_MIN);
409
410 allDataTypes->GoToNextRow();
411
412 allDataTypes->GetLong(2, int64Value);
413 EXPECT_EQ(int64Value, INT64_MAX);
414
415 allDataTypes->GetDouble(3, doubleVal);
416 EXPECT_EQ(doubleVal, DBL_MAX);
417 }