1 /*
2 * Copyright (c) 2023 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 #include <gtest/gtest.h>
16 #include <sys/stat.h>
17 #include <sys/types.h>
18
19 #include <string>
20
21 #include "accesstoken_kit.h"
22 #include "common.h"
23 #include "rdb_errno.h"
24 #include "relational_store.h"
25 #include "relational_store_error_code.h"
26 #include "relational_store_impl.h"
27 #include "token_setproc.h"
28
29 using namespace testing::ext;
30 using namespace OHOS::NativeRdb;
31 using namespace OHOS::Security::AccessToken;
32 using namespace OHOS::RdbNdk;
33
34 class RdbNativeStoreTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
InitRdbConfig()40 static void InitRdbConfig()
41 {
42 config_.dataBaseDir = RDB_TEST_PATH;
43 config_.storeName = "rdb_store_test.db";
44 config_.bundleName = "com.ohos.example.distributedndk";
45 config_.moduleName = "";
46 config_.securityLevel = OH_Rdb_SecurityLevel::S1;
47 config_.isEncrypt = false;
48 config_.selfSize = sizeof(OH_Rdb_Config);
49 config_.area = RDB_SECURITY_AREA_EL1;
50 }
51 static OH_Rdb_Config config_;
52 static void MockHap(void);
53 };
54
55 OH_Rdb_Store *storeTestRdbStore_;
56 OH_Rdb_Config RdbNativeStoreTest::config_ = { 0 };
57
MockHap(void)58 void RdbNativeStoreTest::MockHap(void)
59 {
60 HapInfoParams info = {
61 .userID = 100, .bundleName = "com.example.distributed", .instIndex = 0, .appIDDesc = "com.example.distributed"
62 };
63 PermissionDef infoManagerTestPermDef = { .permissionName = "ohos.permission.test",
64 .bundleName = "com.example.distributed",
65 .grantMode = 1,
66 .availableLevel = APL_NORMAL,
67 .label = "label",
68 .labelId = 1,
69 .description = "open the door",
70 .descriptionId = 1 };
71 PermissionStateFull infoManagerTestState = { .permissionName = "ohos.permission.test",
72 .isGeneral = true,
73 .resDeviceID = { "local" },
74 .grantStatus = { PermissionState::PERMISSION_GRANTED },
75 .grantFlags = { 1 } };
76 HapPolicyParams policy = { .apl = APL_NORMAL,
77 .domain = "test.domain",
78 .permList = { infoManagerTestPermDef },
79 .permStateList = { infoManagerTestState } };
80 AccessTokenKit::AllocHapToken(info, policy);
81 }
82
SetUpTestCase(void)83 void RdbNativeStoreTest::SetUpTestCase(void)
84 {
85 MockHap();
86 InitRdbConfig();
87 mkdir(config_.dataBaseDir, 0770);
88 int errCode = 0;
89 storeTestRdbStore_ = OH_Rdb_GetOrOpen(&config_, &errCode);
90 EXPECT_NE(storeTestRdbStore_, NULL);
91 }
92
TearDownTestCase(void)93 void RdbNativeStoreTest::TearDownTestCase(void)
94 {
95 int errCode = OH_Rdb_CloseStore(storeTestRdbStore_);
96 EXPECT_EQ(errCode, 0);
97 errCode = OH_Rdb_DeleteStore(&config_);
98 EXPECT_EQ(errCode, 0);
99 }
100
SetUp(void)101 void RdbNativeStoreTest::SetUp(void)
102 {
103 char createTableSql[] = "CREATE TABLE store_test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
104 "data3 FLOAT, data4 BLOB, data5 TEXT);";
105 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
106 EXPECT_EQ(errCode, 0);
107
108 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
109 valueBucket->putInt64(valueBucket, "id", 1);
110 valueBucket->putText(valueBucket, "data1", "zhangSan");
111 valueBucket->putInt64(valueBucket, "data2", 12800);
112 valueBucket->putReal(valueBucket, "data3", 100.1);
113 uint8_t arr[] = { 1, 2, 3, 4, 5 };
114 int len = sizeof(arr) / sizeof(arr[0]);
115 valueBucket->putBlob(valueBucket, "data4", arr, len);
116 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
117 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
118 EXPECT_EQ(errCode, 1);
119
120 char querySql[] = "SELECT * FROM store_test";
121 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
122
123 int rowCount = 0;
124 cursor->getRowCount(cursor, &rowCount);
125 EXPECT_EQ(rowCount, 1);
126 cursor->destroy(cursor);
127 valueBucket->destroy(valueBucket);
128 }
129
TearDown(void)130 void RdbNativeStoreTest::TearDown(void)
131 {
132 char dropTableSql[] = "DROP TABLE IF EXISTS store_test";
133 int errCode = OH_Rdb_Execute(storeTestRdbStore_, dropTableSql);
134 EXPECT_EQ(errCode, 0);
135 }
136
CloudSyncObserverCallback(void * context,Rdb_ProgressDetails * progressDetails)137 void CloudSyncObserverCallback(void *context, Rdb_ProgressDetails *progressDetails)
138 {
139 EXPECT_NE(progressDetails, nullptr);
140 EXPECT_EQ(progressDetails->version, DISTRIBUTED_PROGRESS_DETAIL_VERSION);
141 EXPECT_EQ(progressDetails->schedule, Rdb_Progress::RDB_SYNC_FINISH);
142 EXPECT_EQ(progressDetails->code, Rdb_ProgressCode::RDB_CLOUD_DISABLED);
143 EXPECT_EQ(progressDetails->tableLength, 0);
144 Rdb_TableDetails *tableDetails = OH_Rdb_GetTableDetails(progressDetails, DISTRIBUTED_PROGRESS_DETAIL_VERSION);
145 EXPECT_NE(tableDetails, nullptr);
146 }
147
CloudSyncCallback(Rdb_ProgressDetails * progressDetails)148 void CloudSyncCallback(Rdb_ProgressDetails *progressDetails)
149 {
150 CloudSyncObserverCallback(nullptr, progressDetails);
151 }
152
153 Rdb_ProgressCallback callback = CloudSyncObserverCallback;
154 Rdb_ProgressObserver observer = { nullptr, callback };
155
156 /**
157 * @tc.name: RDB_Native_store_test_001
158 * @tc.desc: Normal testCase of store for Update、Query.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_001, TestSize.Level1)
162 {
163 int errCode = 0;
164 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
165 valueBucket->putText(valueBucket, "data1", "liSi");
166 valueBucket->putInt64(valueBucket, "data2", 13800);
167 valueBucket->putReal(valueBucket, "data3", 200.1);
168 valueBucket->putNull(valueBucket, "data5");
169
170 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
171 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
172 const char *data1Value = "zhangSan";
173 valueObject->putText(valueObject, data1Value);
174 predicates->equalTo(predicates, "data1", valueObject);
175 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
176 EXPECT_EQ(errCode, 1);
177
178 predicates->clear(predicates);
179 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
180 EXPECT_NE(cursor, NULL);
181
182 int rowCount = 0;
183 cursor->getRowCount(cursor, &rowCount);
184 EXPECT_EQ(rowCount, 1);
185
186 errCode = cursor->goToNextRow(cursor);
187 EXPECT_EQ(errCode, 0);
188
189 size_t size = 0;
190 cursor->getSize(cursor, 1, &size);
191 char data1Value_1[size + 1];
192 cursor->getText(cursor, 1, data1Value_1, size + 1);
193 EXPECT_EQ(strcmp(data1Value_1, "liSi"), 0);
194
195 int64_t data2Value;
196 cursor->getInt64(cursor, 2, &data2Value);
197 EXPECT_EQ(data2Value, 13800);
198
199 double data3Value;
200 cursor->getReal(cursor, 3, &data3Value);
201 EXPECT_EQ(data3Value, 200.1);
202
203 cursor->getSize(cursor, 4, &size);
204 unsigned char data4Value[size];
205 cursor->getBlob(cursor, 4, data4Value, size);
206 EXPECT_EQ(data4Value[0], 1);
207 EXPECT_EQ(data4Value[1], 2);
208
209 bool isNull = false;
210 cursor->isNull(cursor, 5, &isNull);
211 EXPECT_EQ(isNull, true);
212
213 valueObject->destroy(valueObject);
214 valueBucket->destroy(valueBucket);
215 predicates->destroy(predicates);
216 cursor->destroy(cursor);
217 }
218
219 /**
220 * @tc.name: RDB_Native_store_test_002
221 * @tc.desc: Normal testCase of store for Delete、ExecuteQuery.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_002, TestSize.Level1)
225 {
226 int errCode = 0;
227 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
228 valueBucket->putInt64(valueBucket, "id", 2);
229 valueBucket->putText(valueBucket, "data1", "liSi");
230 valueBucket->putInt64(valueBucket, "data2", 13800);
231 valueBucket->putReal(valueBucket, "data3", 200.1);
232 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
233 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
234 EXPECT_EQ(errCode, 2);
235
236 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
237 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
238 const char *data1Value = "zhangSan";
239 valueObject->putText(valueObject, data1Value);
240 predicates->equalTo(predicates, "data1", valueObject);
241 errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates);
242 EXPECT_EQ(errCode, 1);
243
244 char querySql[] = "SELECT * FROM store_test";
245 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
246
247 int rowCount = 0;
248 cursor->getRowCount(cursor, &rowCount);
249 EXPECT_EQ(rowCount, 1);
250
251 errCode = cursor->goToNextRow(cursor);
252 EXPECT_EQ(errCode, 0);
253
254 size_t size = 0;
255 cursor->getSize(cursor, 1, &size);
256 char data1Value_1[size + 1];
257 cursor->getText(cursor, 1, data1Value_1, size + 1);
258 EXPECT_EQ(strcmp(data1Value_1, "liSi"), 0);
259
260 int64_t data2Value;
261 cursor->getInt64(cursor, 2, &data2Value);
262 EXPECT_EQ(data2Value, 13800);
263
264 double data3Value;
265 cursor->getReal(cursor, 3, &data3Value);
266 EXPECT_EQ(data3Value, 200.1);
267
268 bool isNull = false;
269 cursor->isNull(cursor, 4, &isNull);
270 EXPECT_EQ(isNull, true);
271
272 cursor->getSize(cursor, 5, &size);
273 char data5Value[size + 1];
274 cursor->getText(cursor, 5, data5Value, size + 1);
275 EXPECT_EQ(strcmp(data5Value, "ABCDEFGH"), 0);
276
277 valueObject->destroy(valueObject);
278 valueBucket->destroy(valueBucket);
279 predicates->destroy(predicates);
280 cursor->destroy(cursor);
281 }
282
283 /**
284 * @tc.name: RDB_Native_store_test_003
285 * @tc.desc: Normal testCase of store for Transaction、Commit.
286 * @tc.type: FUNC
287 */
288 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_003, TestSize.Level1)
289 {
290 OH_Rdb_BeginTransaction(storeTestRdbStore_);
291
292 int errCode = 0;
293 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
294 valueBucket->putInt64(valueBucket, "id", 2);
295 valueBucket->putText(valueBucket, "data1", "liSi");
296 valueBucket->putInt64(valueBucket, "data2", 13800);
297 valueBucket->putReal(valueBucket, "data3", 200.1);
298 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
299 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
300 EXPECT_EQ(errCode, 2);
301
302 OH_Rdb_Commit(storeTestRdbStore_);
303
304 char querySql[] = "SELECT * FROM store_test";
305 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
306
307 int rowCount = 0;
308 cursor->getRowCount(cursor, &rowCount);
309 EXPECT_EQ(rowCount, 2);
310
311 valueBucket->destroy(valueBucket);
312 cursor->destroy(cursor);
313 }
314
315 /**
316 * @tc.name: RDB_Native_store_test_004
317 * @tc.desc: Normal testCase of store for Transaction、RollBack.
318 * @tc.type: FUNC
319 */
320 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_004, TestSize.Level1)
321 {
322 OH_Rdb_BeginTransaction(storeTestRdbStore_);
323
324 int errCode = 0;
325 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
326 valueBucket->putInt64(valueBucket, "id", 2);
327 valueBucket->putText(valueBucket, "data1", "liSi");
328 valueBucket->putInt64(valueBucket, "data2", 13800);
329 valueBucket->putReal(valueBucket, "data3", 200.1);
330 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
331 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
332 EXPECT_EQ(errCode, 2);
333
334 OH_Rdb_RollBack(storeTestRdbStore_);
335
336 char querySql[] = "SELECT * FROM store_test";
337 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
338
339 int rowCount = 0;
340 cursor->getRowCount(cursor, &rowCount);
341 EXPECT_EQ(rowCount, 1); // 回退至函数之前的状态
342
343 valueBucket->destroy(valueBucket);
344 cursor->destroy(cursor);
345 }
346
347 /**
348 * @tc.name: RDB_Native_store_test_005
349 * @tc.desc: Normal testCase of store for Backup、Restore.
350 * @tc.type: FUNC
351 */
352 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_005, TestSize.Level1)
353 {
354 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
355 valueBucket->putText(valueBucket, "data1", "zhangSan");
356 valueBucket->putInt64(valueBucket, "data2", 12800);
357 valueBucket->putReal(valueBucket, "data3", 100.1);
358
359 std::string backupPath1 = RDB_TEST_PATH + std::string("a.db");
360 int errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath1.c_str());
361 EXPECT_EQ(errCode, 0);
362
363 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
364 EXPECT_EQ(errCode, 2);
365 std::string backupPath2 = RDB_TEST_PATH + std::string("b.db");
366 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath2.c_str());
367 EXPECT_EQ(errCode, 0);
368
369 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
370 EXPECT_EQ(errCode, 3);
371 std::string backupPath3 = RDB_TEST_PATH + std::string("c.db");
372 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath3.c_str());
373 EXPECT_EQ(errCode, 0);
374
375 // Continuous backup
376 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
377 EXPECT_EQ(errCode, 4);
378 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath3.c_str());
379 EXPECT_EQ(errCode, 0);
380
381 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath1.c_str());
382 EXPECT_EQ(errCode, 0);
383 char querySql[] = "SELECT * FROM store_test";
384 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
385 int rowCount = 0;
386 cursor->getRowCount(cursor, &rowCount);
387 EXPECT_EQ(rowCount, 1);
388 cursor->destroy(cursor);
389
390 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath2.c_str());
391 EXPECT_EQ(errCode, 0);
392 cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
393 cursor->getRowCount(cursor, &rowCount);
394 EXPECT_EQ(rowCount, 2);
395 cursor->destroy(cursor);
396
397 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath3.c_str());
398 EXPECT_EQ(errCode, 0);
399 cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
400 cursor->getRowCount(cursor, &rowCount);
401 EXPECT_EQ(rowCount, 4);
402 cursor->destroy(cursor);
403
404 // Continuous restore
405 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath3.c_str());
406 EXPECT_EQ(errCode, 0);
407 cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
408 cursor->getRowCount(cursor, &rowCount);
409 EXPECT_EQ(rowCount, 4);
410
411 valueBucket->destroy(valueBucket);
412 cursor->destroy(cursor);
413 }
414
415 /**
416 * @tc.name: RDB_Native_store_test_006
417 * @tc.desc: Normal testCase of store for Backup、Restore.
418 * @tc.type: FUNC
419 */
420 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_006, TestSize.Level1)
421 {
422 int errCode = 0;
423 char querySql[] = "SELECT * FROM store_test";
424 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
425
426 int rowCount = 0;
427 cursor->getRowCount(cursor, &rowCount);
428 EXPECT_EQ(rowCount, 1);
429 cursor->destroy(cursor);
430
431 std::string backupPath = "backup.db";
432 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
433 EXPECT_EQ(errCode, 0);
434 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath.c_str());
435 EXPECT_EQ(errCode, 0);
436 cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
437 cursor->getRowCount(cursor, &rowCount);
438 EXPECT_EQ(rowCount, 1);
439 cursor->destroy(cursor);
440
441 std::string restorePath = "error.db";
442 errCode = OH_Rdb_Restore(storeTestRdbStore_, restorePath.c_str());
443 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
444 }
445
446 /**
447 * @tc.name: RDB_Native_store_test_007
448 * @tc.desc: Normal testCase of store for Backup、Restore.
449 * @tc.type: FUNC
450 */
451 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_007, TestSize.Level1)
452 {
453 int errCode = 0;
454 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
455 valueBucket->putText(valueBucket, "data1", "zhangSan");
456 valueBucket->putInt64(valueBucket, "data2", 12800);
457 valueBucket->putReal(valueBucket, "data3", 100.1);
458 uint8_t arr[] = { 1, 2, 3, 4, 5 };
459 int len = sizeof(arr) / sizeof(arr[0]);
460 valueBucket->putBlob(valueBucket, "data4", arr, len);
461 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
462
463 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
464 EXPECT_EQ(errCode, 2);
465 std::string backupPath = " ";
466 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
467 EXPECT_EQ(errCode, 0);
468 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath.c_str());
469 EXPECT_EQ(errCode, 0);
470 char querySql[] = "SELECT * FROM store_test";
471 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
472
473 int rowCount = 0;
474 cursor->getRowCount(cursor, &rowCount);
475 EXPECT_EQ(rowCount, 2);
476 cursor->destroy(cursor);
477
478 backupPath = "";
479 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
480 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
481
482 backupPath = RDB_TEST_PATH + std::string("/backup/backup.db");
483 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
484 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
485
486 backupPath = RDB_TEST_PATH;
487 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
488 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
489
490 std::string restorePath = RDB_TEST_PATH;
491 errCode = OH_Rdb_Restore(storeTestRdbStore_, restorePath.c_str());
492 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
493
494 valueBucket->destroy(valueBucket);
495 }
496
497 /**
498 * @tc.name: RDB_Native_store_test_008
499 * @tc.desc: Normal testCase of store for GetVersion、SetVersion.
500 * @tc.type: FUNC
501 */
502 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_008, TestSize.Level1)
503 {
504 int errCode = 0;
505 int version = 0;
506 int setVersion = 3;
507 errCode = OH_Rdb_GetVersion(storeTestRdbStore_, &version);
508 EXPECT_EQ(errCode, 0);
509 EXPECT_EQ(version, 0);
510
511 errCode = OH_Rdb_SetVersion(storeTestRdbStore_, setVersion);
512 errCode = OH_Rdb_GetVersion(storeTestRdbStore_, &version);
513 EXPECT_EQ(errCode, 0);
514 EXPECT_EQ(version, 3);
515 }
516
517 /**
518 * @tc.name: RDB_Native_store_test_009
519 * @tc.desc: Normal testCase of store for Insert with wrong table name or table is NULL.
520 * @tc.type: FUNC
521 */
522 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_009, TestSize.Level1)
523 {
524 int errCode = 0;
525 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
526 valueBucket->putInt64(valueBucket, "id", 2);
527 valueBucket->putText(valueBucket, "data1", "liSi");
528 valueBucket->putInt64(valueBucket, "data2", 13800);
529 valueBucket->putReal(valueBucket, "data3", 200.1);
530 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
531 errCode = OH_Rdb_Insert(storeTestRdbStore_, "wrong", valueBucket);
532 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_ERR);
533
534 valueBucket->clear(valueBucket);
535 valueBucket->putInt64(valueBucket, "id", 3);
536 valueBucket->putText(valueBucket, "data1", "wangWu");
537 valueBucket->putInt64(valueBucket, "data2", 14800);
538 valueBucket->putReal(valueBucket, "data3", 300.1);
539 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
540 char *table = NULL;
541 errCode = OH_Rdb_Insert(storeTestRdbStore_, table, valueBucket);
542 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
543 errCode = OH_Rdb_Insert(nullptr, "wrong", valueBucket);
544 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
545 errCode = OH_Rdb_Insert(storeTestRdbStore_, "wrong", nullptr);
546 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
547
548 char querySql[] = "SELECT * FROM store_test";
549 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
550
551 int rowCount = 0;
552 cursor->getRowCount(cursor, &rowCount);
553 EXPECT_EQ(rowCount, 1);
554
555 valueBucket->destroy(valueBucket);
556 cursor->destroy(cursor);
557 }
558
559 /**
560 * @tc.name: RDB_Native_store_test_0010
561 * @tc.desc: Normal testCase of store for Update with wrong table or table is NULL.
562 * @tc.type: FUNC
563 */
564 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_0010, TestSize.Level1)
565 {
566 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
567 valueBucket->putText(valueBucket, "data1", "liSi");
568 valueBucket->putInt64(valueBucket, "data2", 13800);
569
570 OH_Predicates *predicates = OH_Rdb_CreatePredicates("wrong");
571 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
572 const char *data1Value = "zhangSan";
573 valueObject->putText(valueObject, data1Value);
574 predicates->equalTo(predicates, "data1", valueObject);
575 int errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
576 EXPECT_EQ(errCode, -1);
577
578 char *table = NULL;
579 OH_Predicates *predicates1 = OH_Rdb_CreatePredicates(table);
580 EXPECT_EQ(predicates1, NULL);
581 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates1);
582 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
583 errCode = OH_Rdb_Update(nullptr, valueBucket, predicates);
584 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
585 errCode = OH_Rdb_Update(storeTestRdbStore_, nullptr, predicates);
586 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
587
588 OH_Predicates *predicates2 = OH_Rdb_CreatePredicates("store_test");
589 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates2, NULL, 0);
590 EXPECT_NE(cursor, NULL);
591
592 int rowCount = 0;
593 cursor->getRowCount(cursor, &rowCount);
594 EXPECT_EQ(rowCount, 1);
595
596 errCode = cursor->goToNextRow(cursor);
597 EXPECT_EQ(errCode, 0);
598
599 size_t size = 0;
600 cursor->getSize(cursor, 1, &size);
601 char data1Value_1[size + 1];
602 cursor->getText(cursor, 1, data1Value_1, size + 1);
603 EXPECT_EQ(strcmp(data1Value_1, "zhangSan"), 0);
604
605 int64_t data2Value;
606 cursor->getInt64(cursor, 2, &data2Value);
607 EXPECT_EQ(data2Value, 12800);
608
609 double data3Value;
610 cursor->getReal(cursor, 3, &data3Value);
611 EXPECT_EQ(data3Value, 100.1);
612
613 cursor->getSize(cursor, 4, &size);
614 unsigned char data4Value[size];
615 cursor->getBlob(cursor, 4, data4Value, size);
616 EXPECT_EQ(data4Value[0], 1);
617 EXPECT_EQ(data4Value[1], 2);
618
619 valueObject->destroy(valueObject);
620 predicates->destroy(predicates);
621 predicates2->destroy(predicates2);
622 valueBucket->destroy(valueBucket);
623 cursor->destroy(cursor);
624 }
625
626 /**
627 * @tc.name: RDB_Native_store_test_011
628 * @tc.desc: Abnormal testCase of store for Query.
629 * @tc.type: FUNC
630 */
631 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_011, TestSize.Level1)
632 {
633 char *querySql = NULL;
634 // sql is nullptr
635 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
636 EXPECT_EQ(cursor, NULL);
637 // store is nullptr
638 cursor = OH_Rdb_ExecuteQuery(nullptr, querySql);
639 EXPECT_EQ(cursor, NULL);
640
641 // store is nullptr
642 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
643 cursor = OH_Rdb_Query(nullptr, predicates, NULL, 0);
644 EXPECT_EQ(cursor, NULL);
645 }
646
647 /**
648 * @tc.name: RDB_Native_store_test_012
649 * @tc.desc: Normal testCase of RelationalValuesBucket for anomalous branch.
650 * @tc.type: FUNC
651 */
652 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_012, TestSize.Level1)
653 {
654 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
655 uint8_t arr[] = { 1, 2, 3, 4, 5 };
656 uint32_t len = sizeof(arr) / sizeof(arr[0]);
657 int errCode = valueBucket->putBlob(nullptr, "data4", arr, len);
658 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
659 errCode = valueBucket->putBlob(valueBucket, nullptr, arr, len);
660 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
661 errCode = valueBucket->putBlob(valueBucket, "data4", nullptr, len);
662 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_OK);
663
664 errCode = valueBucket->clear(nullptr);
665 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
666 errCode = valueBucket->destroy(nullptr);
667 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
668 valueBucket->destroy(valueBucket);
669 }
670
671 /**
672 * @tc.name: RDB_Native_store_test_013
673 * @tc.desc: Normal testCase of store for CloudSync.
674 * @tc.type: FUNC
675 */
676 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_013, TestSize.Level1)
677 {
678 EXPECT_NE(storeTestRdbStore_, nullptr);
679 constexpr int TABLE_COUNT = 1;
680 const char *table[TABLE_COUNT];
681 table[0] = "store_test";
682 EXPECT_EQ(table[0], "store_test");
683 Rdb_ProgressObserver observer;
684 void *context = nullptr;
685 observer.context = &context;
686 observer.callback = CloudSyncObserverCallback;
687 auto errorCode =
688 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_TIME_FIRST, table, TABLE_COUNT, &observer);
689 EXPECT_EQ(errorCode, RDB_OK);
690
691 errorCode =
692 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_CLOUD_FIRST, table, TABLE_COUNT, &observer);
693 EXPECT_EQ(errorCode, RDB_OK);
694
695 errorCode =
696 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_NATIVE_FIRST, table, TABLE_COUNT, &observer);
697 EXPECT_EQ(errorCode, RDB_OK);
698
699 errorCode =
700 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_NATIVE_FIRST, table, TABLE_COUNT, nullptr);
701 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
702 }
703
704 /**
705 * @tc.name: RDB_Native_store_test_014
706 * @tc.desc: Abnormal testCase of store for SetDistributedTables.
707 * @tc.type: FUNC
708 */
709 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_014, TestSize.Level1)
710 {
711 EXPECT_NE(storeTestRdbStore_, nullptr);
712 Rdb_DistributedConfig config{ .version = 0, .isAutoSync = true };
713 constexpr int TABLE_COUNT = 1;
714 const char *table[TABLE_COUNT];
715 table[0] = "store_test";
716 int errcode = OH_Rdb_SetDistributedTables(
717 storeTestRdbStore_, table, TABLE_COUNT, Rdb_DistributedType::RDB_DISTRIBUTED_CLOUD, &config);
718 EXPECT_EQ(errcode, RDB_E_INVALID_ARGS);
719 config.version = DISTRIBUTED_CONFIG_VERSION;
720 errcode =
721 OH_Rdb_SetDistributedTables(nullptr, table, TABLE_COUNT, Rdb_DistributedType::RDB_DISTRIBUTED_CLOUD, &config);
722 EXPECT_EQ(errcode, RDB_E_INVALID_ARGS);
723 }
724
725 /**
726 * @tc.name: RDB_Native_store_test_015
727 * @tc.desc: Normal testCase of store for CloudSync.
728 * @tc.type: FUNC
729 */
730 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_015, TestSize.Level1)
731 {
732 EXPECT_NE(storeTestRdbStore_, nullptr);
733 constexpr int TABLE_COUNT = 1;
734 const char *table[TABLE_COUNT];
735 table[0] = "store_test";
736 Rdb_ProgressObserver observer;
737 void *context = nullptr;
738 observer.context = context;
739 observer.callback = CloudSyncObserverCallback;
740 auto errorCode =
741 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_TIME_FIRST, table, TABLE_COUNT, &observer);
742 EXPECT_EQ(errorCode, RDB_OK);
743
744 errorCode =
745 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_CLOUD_FIRST, table, TABLE_COUNT, &observer);
746 EXPECT_EQ(errorCode, RDB_OK);
747
748 errorCode =
749 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_NATIVE_FIRST, table, TABLE_COUNT, &observer);
750 EXPECT_EQ(errorCode, RDB_OK);
751 }
752
753 /**
754 * @tc.name: RDB_Native_store_test_016
755 * @tc.desc: Abnormal testCase of store for CloudSync.
756 * @tc.type: FUNC
757 */
758 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_016, TestSize.Level1)
759 {
760 EXPECT_NE(storeTestRdbStore_, nullptr);
761 constexpr int TABLE_COUNT = 1;
762 const char *table[TABLE_COUNT];
763 table[0] = "store_test";
764 Rdb_ProgressObserver observer;
765 void *context = nullptr;
766 observer.context = context;
767 observer.callback = CloudSyncObserverCallback;
768 auto errorCode =
769 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_TIME_FIRST, table, TABLE_COUNT, nullptr);
770 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
771 errorCode = OH_Rdb_CloudSync(nullptr, Rdb_SyncMode::RDB_SYNC_MODE_CLOUD_FIRST, table, TABLE_COUNT, &observer);
772 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
773 }
774
775 /**
776 * @tc.name: RDB_Native_store_test_017
777 * @tc.desc: Normal testCase for GetModifyTime.
778 * @tc.type: FUNC
779 */
780 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_017, TestSize.Level1)
781 {
782 char createLogTableSql[] = "CREATE TABLE if not exists naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
783 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
784 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);";
785 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createLogTableSql);
786 EXPECT_EQ(errCode, RDB_OK);
787 OH_VBucket *bucket = OH_Rdb_CreateValuesBucket();
788 bucket->putInt64(bucket, "data_key", 1);
789 bucket->putInt64(bucket, "timestamp", 1000000000);
790 errCode = OH_Rdb_Insert(storeTestRdbStore_, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", bucket);
791 EXPECT_EQ(errCode, 1);
792
793 OH_VObject *values = OH_Rdb_CreateValueObject();
794 int64_t keys[] = { 1 };
795 values->putInt64(values, keys, 1);
796
797 OH_Cursor *cursor;
798 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdbstoreimpltest_integer", "ROWID", values);
799 int rowCount;
800 errCode = cursor->getRowCount(cursor, &rowCount);
801 EXPECT_EQ(errCode, RDB_OK);
802 EXPECT_EQ(rowCount, 1);
803 cursor->goToNextRow(cursor);
804 int64_t key = 0;
805 cursor->getInt64(cursor, 0, &key);
806 EXPECT_EQ(key, 1);
807 int64_t time = 0;
808 cursor->getInt64(cursor, 1, &time);
809 EXPECT_EQ(time, 100000);
810
811 cursor->destroy(cursor);
812 char dropLogTableSql[] = "DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log";
813 errCode = OH_Rdb_Execute(storeTestRdbStore_, dropLogTableSql);
814 EXPECT_EQ(errCode, RDB_OK);
815 }
816
817 /**
818 * @tc.name: RDB_Native_store_test_018
819 * @tc.desc: Abnormal testCase for GetModifyTime, tablename columnName, keys is empty,
820 * and resultSet is null or empty
821 * @tc.type: FUNC
822 */
823 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_018, TestSize.Level1)
824 {
825 char createLogTableSql[] = "CREATE TABLE if not exists naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
826 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
827 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);";
828 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createLogTableSql);
829 EXPECT_EQ(errCode, RDB_OK);
830 OH_VBucket *bucket = OH_Rdb_CreateValuesBucket();
831 bucket->putInt64(bucket, "data_key", 1);
832 bucket->putInt64(bucket, "timestamp", 1000000000);
833 errCode = OH_Rdb_Insert(storeTestRdbStore_, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", bucket);
834 EXPECT_EQ(errCode, 1);
835
836 OH_VObject *values = OH_Rdb_CreateValueObject();
837 int64_t keys[] = { 1 };
838 values->putInt64(values, keys, 1);
839
840 // store is nullptr
841 OH_Cursor *cursor = OH_Rdb_FindModifyTime(nullptr, "rdbstoreimpltest_integer", "data_key", values);
842 EXPECT_EQ(cursor, nullptr);
843
844 // tabel name is nullptr
845 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, nullptr, "data_key", values);
846 EXPECT_EQ(cursor, nullptr);
847
848 // key is nullptr
849 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdbstoreimpltest_integer", "data_key", nullptr);
850 EXPECT_EQ(cursor, nullptr);
851
852 // table name is ""
853 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "", "data_key", values);
854 int rowCount = 0;
855 errCode = cursor->getRowCount(cursor, &rowCount);
856 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
857
858 // table name is not exist , resultSet is null
859 cursor->destroy(cursor);
860 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "test", "data_key", values);
861 cursor->getRowCount(cursor, &rowCount);
862 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
863
864 // columnName is ""
865 cursor->destroy(cursor);
866 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdbstoreimpltest_integer", "", values);
867 cursor->getRowCount(cursor, &rowCount);
868 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
869
870 // keys is empty
871 cursor->destroy(cursor);
872 OH_VObject *emptyValues = OH_Rdb_CreateValueObject();
873 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdb_aux_rdbstoreimpltest_integer", "data_key", emptyValues);
874 cursor->getRowCount(cursor, &rowCount);
875 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
876
877 cursor->destroy(cursor);
878 char dropLogTableSql[] = "DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log";
879 errCode = OH_Rdb_Execute(storeTestRdbStore_, dropLogTableSql);
880 EXPECT_EQ(errCode, RDB_OK);
881 }
882
883 /**
884 * @tc.name: RDB_Native_store_test_019
885 * @tc.desc: testCase for OH_Rdb_SubscribeAutoSyncProgress test.
886 * @tc.type: FUNC
887 */
888 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_019, TestSize.Level1)
889 {
890 EXPECT_NE(storeTestRdbStore_, nullptr);
891 EXPECT_EQ(OH_Rdb_SubscribeAutoSyncProgress(storeTestRdbStore_, &observer), RDB_OK);
892 EXPECT_EQ(OH_Rdb_SubscribeAutoSyncProgress(storeTestRdbStore_, &observer), RDB_OK);
893 EXPECT_EQ(OH_Rdb_SubscribeAutoSyncProgress(storeTestRdbStore_, nullptr), RDB_E_INVALID_ARGS);
894 EXPECT_EQ(OH_Rdb_SubscribeAutoSyncProgress(nullptr, &observer), RDB_E_INVALID_ARGS);
895 }
896
897 /**
898 * @tc.name: RDB_Native_store_test_020
899 * @tc.desc: testCase for OH_Rdb_UnsubscribeAutoSyncProgress test.
900 * @tc.type: FUNC
901 */
902 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_020, TestSize.Level1)
903 {
904 EXPECT_NE(storeTestRdbStore_, nullptr);
905 EXPECT_EQ(OH_Rdb_UnsubscribeAutoSyncProgress(storeTestRdbStore_, &observer), RDB_OK);
906 EXPECT_EQ(OH_Rdb_UnsubscribeAutoSyncProgress(storeTestRdbStore_, &observer), RDB_OK);
907 EXPECT_EQ(OH_Rdb_UnsubscribeAutoSyncProgress(storeTestRdbStore_, nullptr), RDB_OK);
908 EXPECT_EQ(OH_Rdb_UnsubscribeAutoSyncProgress(nullptr, &observer), RDB_E_INVALID_ARGS);
909 }
910
911 /**
912 * @tc.name: Abnormal_RDB_OH_interface_test_021
913 * @tc.desc: Abnormal testCase of store for OH interface.
914 * @tc.type: FUNC
915 */
916 HWTEST_F(RdbNativeStoreTest, Abnormal_RDB_OH_interface_test_021, TestSize.Level1)
917 {
918 OH_Rdb_Config config;
919 int errCode = E_OK;
920 OH_Rdb_Store *rdbStore;
921 rdbStore = OH_Rdb_GetOrOpen(nullptr, &errCode);
922 EXPECT_EQ(rdbStore, nullptr);
923 EXPECT_EQ(errCode, E_OK);
924
925 rdbStore = OH_Rdb_GetOrOpen(&config, nullptr);
926 EXPECT_EQ(rdbStore, nullptr);
927
928 config.selfSize = INT_MAX;
929 rdbStore = OH_Rdb_GetOrOpen(&config, nullptr);
930 EXPECT_EQ(rdbStore, nullptr);
931
932 config.dataBaseDir = RDB_TEST_PATH;
933 config.storeName = "rdb_store_abnormal_test.db";
934 config.bundleName = "com.example.distributed";
935 config.moduleName = "";
936 config.securityLevel = OH_Rdb_SecurityLevel::S1;
937 config.isEncrypt = false;
938 config.selfSize = sizeof(OH_Rdb_Config);
939 config.area = RDB_SECURITY_AREA_EL1;
940
941 errCode = 0;
942 errCode = OH_Rdb_DeleteStore(nullptr);
943 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
944
945 config.dataBaseDir = nullptr;
946 errCode = OH_Rdb_DeleteStore(&config);
947 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
948
949 config.dataBaseDir = RDB_TEST_PATH;
950 config.storeName = nullptr;
951 errCode = OH_Rdb_DeleteStore(&config);
952 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
953 }
954
955 /**
956 * @tc.name: Abnormal_RDB_OH_interface_test_022
957 * @tc.desc: Abnormal testCase of store for OH interface.
958 * @tc.type: FUNC
959 */
960 HWTEST_F(RdbNativeStoreTest, Abnormal_RDB_OH_interface_test_022, TestSize.Level1)
961 {
962 char createTableSql[] = "CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER);";
963 int errCode = OH_Rdb_Execute(nullptr, createTableSql);
964 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
965 errCode = OH_Rdb_Execute(storeTestRdbStore_, nullptr);
966 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
967
968 errCode = OH_Rdb_Backup(nullptr, RDB_TEST_PATH);
969 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
970 errCode = OH_Rdb_Backup(storeTestRdbStore_, nullptr);
971 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
972
973 errCode = OH_Rdb_BeginTransaction(nullptr);
974 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
975
976 errCode = OH_Rdb_Commit(nullptr);
977 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
978
979 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
980 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
981 const char *data1Value = "zhangSan";
982 valueObject->putText(valueObject, data1Value);
983 predicates->equalTo(predicates, "data1", valueObject);
984 errCode = OH_Rdb_Delete(nullptr, predicates);
985 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
986 errCode = OH_Rdb_Delete(storeTestRdbStore_, nullptr);
987 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
988
989 errCode = OH_Rdb_RollBack(nullptr);
990 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
991
992 errCode = OH_Rdb_Restore(nullptr, RDB_TEST_PATH);
993 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
994 errCode = OH_Rdb_Restore(storeTestRdbStore_, nullptr);
995 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
996
997 int version = 2;
998 errCode = OH_Rdb_SetVersion(nullptr, version);
999 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1000
1001 errCode = OH_Rdb_GetVersion(nullptr, &version);
1002 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1003 errCode = OH_Rdb_GetVersion(storeTestRdbStore_, nullptr);
1004 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1005
1006 errCode = OH_Rdb_CloseStore(nullptr);
1007 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
1008 }
1009
1010 /**
1011 * @tc.name: RDB_Native_store_test_023
1012 * @tc.desc: Normal testCase of store for Lock/Unlock and QueryLockedRow.
1013 * @tc.type: FUNC
1014 */
1015 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_023, TestSize.Level1)
1016 {
1017 EXPECT_NE(storeTestRdbStore_, nullptr);
1018 char createTableSql[] = "CREATE TABLE lock_test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
1019 "data3 FLOAT, data4 BLOB, data5 TEXT);";
1020 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
1021 EXPECT_EQ(errCode, 0);
1022
1023 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1024 EXPECT_NE(valueBucket, nullptr);
1025 valueBucket->putInt64(valueBucket, "id", 1);
1026 valueBucket->putText(valueBucket, "data1", "wanger");
1027 valueBucket->putInt64(valueBucket, "data2", 12800);
1028 valueBucket->putReal(valueBucket, "data3", 100.1);
1029 uint8_t arr[] = { 1, 2, 3, 4, 5 };
1030 int len = sizeof(arr) / sizeof(arr[0]);
1031 valueBucket->putBlob(valueBucket, "data4", arr, len);
1032 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1033 errCode = OH_Rdb_Insert(storeTestRdbStore_, "lock_test", valueBucket);
1034 EXPECT_EQ(errCode, 1);
1035
1036 OH_Predicates *predicates = OH_Rdb_CreatePredicates("lock_test");
1037 EXPECT_NE(predicates, nullptr);
1038 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1039 EXPECT_NE(valueObject, nullptr);
1040 const char *data1Value = "wanger";
1041 valueObject->putText(valueObject, data1Value);
1042 predicates->equalTo(predicates, "data1", valueObject);
1043 errCode = OH_Rdb_LockRow(storeTestRdbStore_, predicates);
1044 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_NO_ROW_IN_QUERY);
1045
1046 predicates->clear(predicates);
1047 OH_Cursor *cursor = OH_Rdb_QueryLockedRow(storeTestRdbStore_, predicates, NULL, 0);
1048 EXPECT_NE(cursor, NULL);
1049
1050 int rowCount = 0;
1051 cursor->getRowCount(cursor, &rowCount);
1052 EXPECT_EQ(rowCount, -1);
1053
1054 predicates->clear(predicates);
1055 errCode = OH_Rdb_UnlockRow(storeTestRdbStore_, predicates);
1056 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_NO_ROW_IN_QUERY);
1057
1058 predicates->clear(predicates);
1059 cursor = OH_Rdb_QueryLockedRow(storeTestRdbStore_, predicates, NULL, 0);
1060 EXPECT_NE(cursor, NULL);
1061
1062 rowCount = 0;
1063 cursor->getRowCount(cursor, &rowCount);
1064 EXPECT_EQ(rowCount, -1);
1065
1066 valueObject->destroy(valueObject);
1067 valueBucket->destroy(valueBucket);
1068 predicates->destroy(predicates);
1069 cursor->destroy(cursor);
1070 }
1071
LocalDataChangeObserverCallback1(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1072 void LocalDataChangeObserverCallback1(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1073 {
1074 for (uint32_t i = 0; i < count; i++) {
1075 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1076 // 0 represent table name is store_test
1077 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "store_test"), 0);
1078 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1079 // insert row count is 1
1080 EXPECT_EQ(1, changeInfo[i]->inserted.count);
1081 EXPECT_EQ(TYPE_INT64, changeInfo[i]->inserted.type);
1082 // insert rowId is 2
1083 EXPECT_EQ(2, changeInfo[i]->inserted.data->integer);
1084 // update row count is 0
1085 EXPECT_EQ(0, changeInfo[i]->updated.count);
1086 // delete row count is 0
1087 EXPECT_EQ(0, changeInfo[i]->deleted.count);
1088 }
1089 }
1090
1091 /**
1092 * @tc.name: RDB_Native_store_test_024
1093 * @tc.desc: normal testCase for OH_Rdb_Subscribe, insert data into local database
1094 * @tc.type: FUNC
1095 */
1096 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_024, TestSize.Level1)
1097 {
1098 EXPECT_NE(storeTestRdbStore_, nullptr);
1099
1100 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback1;
1101 Rdb_DataObserver observer = { nullptr, { callback } };
1102 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1103
1104 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1105 // id is 2
1106 valueBucket->putInt64(valueBucket, "id", 2);
1107 valueBucket->putText(valueBucket, "data1", "zhangSan");
1108 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
1109 // insert rowId is 2
1110 EXPECT_EQ(2, errCode);
1111
1112 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1113 valueBucket->destroy(valueBucket);
1114 }
1115
LocalDataChangeObserverCallback2(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1116 void LocalDataChangeObserverCallback2(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1117 {
1118 for (uint32_t i = 0; i < count; i++) {
1119 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1120 // 0 represent table name is store_test
1121 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "store_test"), 0);
1122 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1123 EXPECT_EQ(TYPE_INT64, changeInfo[i]->updated.type);
1124 // update row count is 1
1125 EXPECT_EQ(1, changeInfo[i]->updated.count);
1126 // update rowId is 1
1127 EXPECT_EQ(1, changeInfo[i]->updated.data->integer);
1128 // insert row count is 0
1129 EXPECT_EQ(0, changeInfo[i]->inserted.count);
1130 // delete row count is 0
1131 EXPECT_EQ(0, changeInfo[i]->deleted.count);
1132 }
1133 }
1134
1135 /**
1136 * @tc.name: RDB_Native_store_test_025
1137 * @tc.desc: normal testCase for OH_Rdb_Subscribe, update a data into local database
1138 * @tc.type: FUNC
1139 */
1140 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_025, TestSize.Level1)
1141 {
1142 EXPECT_NE(storeTestRdbStore_, nullptr);
1143
1144 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback2;
1145 Rdb_DataObserver observer = { nullptr, { callback } };
1146
1147 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1148
1149 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1150 valueBucket->putText(valueBucket, "data1", "liSi");
1151
1152 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
1153 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1154 const char *data1Value = "zhangSan";
1155 valueObject->putText(valueObject, data1Value);
1156 predicates->equalTo(predicates, "data1", valueObject);
1157 int errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
1158 // update row count is 1
1159 EXPECT_EQ(errCode, 1);
1160
1161 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1162 valueObject->destroy(valueObject);
1163 valueBucket->destroy(valueBucket);
1164 predicates->destroy(predicates);
1165 }
1166
LocalDataChangeObserverCallback3(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1167 void LocalDataChangeObserverCallback3(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1168 {
1169 for (uint32_t i = 0; i < count; i++) {
1170 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1171 // 0 represent table name is 0
1172 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "store_test"), 0);
1173 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1174 EXPECT_EQ(TYPE_INT64, changeInfo[i]->deleted.type);
1175 // delete count is 1
1176 EXPECT_EQ(1, changeInfo[i]->deleted.count);
1177 // delete rowId is 1
1178 EXPECT_EQ(1, changeInfo[i]->deleted.data->integer);
1179 // insert count is 0
1180 EXPECT_EQ(0, changeInfo[i]->inserted.count);
1181 // update count is 0
1182 EXPECT_EQ(0, changeInfo[i]->updated.count);
1183 }
1184 }
1185
1186 /**
1187 * @tc.name: RDB_Native_store_test_026
1188 * @tc.desc: normal testCase for OH_Rdb_Subscribe, delete data into local database
1189 * @tc.type: FUNC
1190 */
1191 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_026, TestSize.Level1)
1192 {
1193 EXPECT_NE(storeTestRdbStore_, nullptr);
1194
1195 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback3;
1196 Rdb_DataObserver observer = { nullptr, { callback } };
1197
1198 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1199
1200 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
1201 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1202 const char *data1Value = "zhangSan";
1203 valueObject->putText(valueObject, data1Value);
1204 predicates->equalTo(predicates, "data1", valueObject);
1205 int errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates);
1206 // delete row count is 1
1207 EXPECT_EQ(errCode, 1);
1208
1209 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1210 valueObject->destroy(valueObject);
1211 predicates->destroy(predicates);
1212 }
1213
1214 /**
1215 * @tc.name: RDB_Native_store_test_027
1216 * @tc.desc: normal testCase for OH_Rdb_Subscribe, register two observers for local database
1217 * @tc.type: FUNC
1218 */
1219 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_027, TestSize.Level1)
1220 {
1221 EXPECT_NE(storeTestRdbStore_, nullptr);
1222
1223 Rdb_DetailsObserver callback1 = LocalDataChangeObserverCallback1;
1224 Rdb_DataObserver observer1 = { nullptr, { callback1 } };
1225
1226 Rdb_DetailsObserver callback2 = LocalDataChangeObserverCallback1;
1227 Rdb_DataObserver observer2 = { nullptr, { callback2 } };
1228
1229 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1230 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1231
1232 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1233 // id is 2
1234 valueBucket->putInt64(valueBucket, "id", 2);
1235 valueBucket->putText(valueBucket, "data1", "zhangSan");
1236 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
1237 // rowId is 2
1238 EXPECT_EQ(2, errCode);
1239
1240 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1241 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1242 valueBucket->destroy(valueBucket);
1243 }
1244
LocalDataChangeObserverCallback4(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1245 void LocalDataChangeObserverCallback4(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1246 {
1247 EXPECT_EQ(0, count);
1248 }
1249
1250 /**
1251 * @tc.name: RDB_Native_store_test_028
1252 * @tc.desc: normal testCase for OH_Rdb_Subscribe.
1253 * 1.register two observers for local database
1254 * 2.unRegister one of observers
1255 * @tc.type: FUNC
1256 */
1257 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_028, TestSize.Level1)
1258 {
1259 EXPECT_NE(storeTestRdbStore_, nullptr);
1260
1261 Rdb_DetailsObserver callback1 = LocalDataChangeObserverCallback4;
1262 Rdb_DataObserver observer1 = { nullptr, { callback1 } };
1263
1264 Rdb_DetailsObserver callback2 = LocalDataChangeObserverCallback1;
1265 Rdb_DataObserver observer2 = { nullptr, { callback2 } };
1266
1267 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1268 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1269 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1270
1271 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1272 // id is 2
1273 valueBucket->putInt64(valueBucket, "id", 2);
1274 valueBucket->putText(valueBucket, "data1", "zhangSan");
1275 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
1276 // rowId is 2
1277 EXPECT_EQ(2, errCode);
1278
1279 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1280 valueBucket->destroy(valueBucket);
1281 }
1282
LocalDataChangeObserverCallback5(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1283 void LocalDataChangeObserverCallback5(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1284 {
1285 for (uint32_t i = 0; i < count; i++) {
1286 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1287 // 0 represent table name is test1
1288 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "test1"), 0);
1289 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1290 // insert a data
1291 EXPECT_EQ(1, changeInfo[i]->inserted.count);
1292 EXPECT_EQ(TYPE_INT64, changeInfo[i]->inserted.type);
1293 // insert rowId is 1
1294 EXPECT_EQ(1, changeInfo[i]->inserted.data->integer);
1295 // update count is 0
1296 EXPECT_EQ(0, changeInfo[i]->updated.count);
1297 // delete count is 0
1298 EXPECT_EQ(0, changeInfo[i]->deleted.count);
1299 }
1300 }
1301
1302 /**
1303 * @tc.name: RDB_Native_store_test_029
1304 * @tc.desc: normal testCase for OH_Rdb_Subscribe.
1305 * 1.register observer for local database
1306 * 2.create new table test
1307 * 3.insert data into table test
1308 * 2.unRegister one of observer
1309 * @tc.type: FUNC
1310 */
1311 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_029, TestSize.Level1)
1312 {
1313 EXPECT_NE(storeTestRdbStore_, nullptr);
1314
1315 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback5;
1316 Rdb_DataObserver observer = { nullptr, { callback } };
1317
1318 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1319
1320 constexpr const char *createTableSql = "CREATE TABLE test1 (id INTEGER PRIMARY KEY AUTOINCREMENT, "
1321 "data1 TEXT, data2 INTEGER, data3 FLOAT, data4 BLOB, data5 TEXT);";
1322 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
1323 // errCode is 0
1324 EXPECT_EQ(errCode, 0);
1325
1326 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1327 valueBucket->putInt64(valueBucket, "id", 1);
1328 valueBucket->putText(valueBucket, "data1", "zhangSan");
1329 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test1", valueBucket);
1330 // rowId is 1
1331 EXPECT_EQ(1, errCode);
1332
1333 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1334
1335 constexpr const char *dropTableSql = "DROP TABLE IF EXISTS test1";
1336 errCode = OH_Rdb_Execute(storeTestRdbStore_, dropTableSql);
1337 // errCode is 0
1338 EXPECT_EQ(errCode, 0);
1339 valueBucket->destroy(valueBucket);
1340 }
1341
LocalDataChangeObserverCallback6(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1342 void LocalDataChangeObserverCallback6(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1343 {
1344 for (uint32_t i = 0; i < count; i++) {
1345 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1346 // 0 represent table name is store_test
1347 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "store_test"), 0);
1348 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1349 // update row count is 2
1350 EXPECT_EQ(2, changeInfo[i]->updated.count);
1351 EXPECT_EQ(TYPE_INT64, changeInfo[i]->updated.type);
1352 // update rowId is 1
1353 EXPECT_EQ(1, changeInfo[i]->updated.data->integer);
1354 // update rowId is 2
1355 EXPECT_EQ(2, ++(changeInfo[i]->updated.data)->integer);
1356 // insert count is 0
1357 EXPECT_EQ(0, changeInfo[i]->inserted.count);
1358 // delete count is 0
1359 EXPECT_EQ(0, changeInfo[i]->deleted.count);
1360 }
1361 }
1362
1363 /**
1364 * @tc.name: RDB_Native_store_test_030
1365 * @tc.desc: normal testCase for OH_Rdb_Subscribe, update two data in local database
1366 * @tc.type: FUNC
1367 */
1368 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_030, TestSize.Level1)
1369 {
1370 EXPECT_NE(storeTestRdbStore_, nullptr);
1371
1372 OH_VBucket *valueBucket1 = OH_Rdb_CreateValuesBucket();
1373 valueBucket1->putText(valueBucket1, "data1", "zhangSan");
1374 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket1);
1375 // rowId is 2
1376 EXPECT_EQ(2, errCode);
1377
1378 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback6;
1379 Rdb_DataObserver observer = { nullptr, { callback } };
1380
1381 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1382
1383 OH_VBucket *valueBucket2 = OH_Rdb_CreateValuesBucket();
1384 valueBucket2->putText(valueBucket2, "data1", "liSi");
1385
1386 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
1387 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1388 const char *data1Value = "zhangSan";
1389 valueObject->putText(valueObject, data1Value);
1390 predicates->equalTo(predicates, "data1", valueObject);
1391 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket2, predicates);
1392 // update row count is 2
1393 EXPECT_EQ(errCode, 2);
1394
1395 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1396 valueObject->destroy(valueObject);
1397 valueBucket1->destroy(valueBucket1);
1398 valueBucket2->destroy(valueBucket2);
1399 predicates->destroy(predicates);
1400 }
1401
LocalDataChangeObserverCallback7(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1402 void LocalDataChangeObserverCallback7(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1403 {
1404 // count is 0
1405 EXPECT_EQ(0, count);
1406 }
1407
LocalDataChangeObserverCallback8(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1408 void LocalDataChangeObserverCallback8(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1409 {
1410 // count is 0
1411 EXPECT_EQ(0, count);
1412 }
1413
1414 /**
1415 * @tc.name: RDB_Native_store_test_031
1416 * @tc.desc: normal testCase for OH_Rdb_Subscribe.
1417 * 1.register two observers for local database
1418 * 2.unRegister one of observers
1419 * @tc.type: FUNC
1420 */
1421 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_031, TestSize.Level1)
1422 {
1423 EXPECT_NE(storeTestRdbStore_, nullptr);
1424
1425 Rdb_DetailsObserver callback1 = LocalDataChangeObserverCallback7;
1426 Rdb_DataObserver observer1 = { nullptr, { callback1 } };
1427
1428 Rdb_DetailsObserver callback2 = LocalDataChangeObserverCallback8;
1429 Rdb_DataObserver observer2 = { nullptr, { callback2 } };
1430
1431 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1432 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1433 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1434 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, nullptr), RDB_OK);
1435
1436 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1437 valueBucket->putInt64(valueBucket, "id", 2);
1438 valueBucket->putText(valueBucket, "data1", "zhangSan");
1439 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
1440 // rowId is 2
1441 EXPECT_EQ(2, errCode);
1442
1443 valueBucket->destroy(valueBucket);
1444 }
1445
1446 /**
1447 * @tc.name: RDB_Native_store_test_032
1448 * @tc.desc: abNormal testCase for OH_Rdb_Subscribe.
1449 * 1.store is nullptr
1450 * 2.register observer for local database
1451 * @tc.type: FUNC
1452 */
1453 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_032, TestSize.Level1)
1454 {
1455 EXPECT_NE(storeTestRdbStore_, nullptr);
1456
1457 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback7;
1458 Rdb_DataObserver observer = { nullptr, { callback } };
1459 EXPECT_EQ(OH_Rdb_Subscribe(nullptr, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_E_INVALID_ARGS);
1460 }
1461
1462 /**
1463 * @tc.name: RDB_Native_store_test_033
1464 * @tc.desc: abNormal testCase for OH_Rdb_Subscribe.
1465 * 1.subscribe type is invalid
1466 * 2.observer is invalid
1467 * 2.register observer for local database
1468 * @tc.type: FUNC
1469 */
1470 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_033, TestSize.Level1)
1471 {
1472 EXPECT_NE(storeTestRdbStore_, nullptr);
1473
1474 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback7;
1475 Rdb_DataObserver observer1 = { nullptr, { callback } };
1476 int errCode = OH_Rdb_Subscribe(nullptr, static_cast<Rdb_SubscribeType>(RDB_SUBSCRIBE_TYPE_CLOUD - 1), &observer1);
1477 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1478 errCode =
1479 OH_Rdb_Subscribe(nullptr, static_cast<Rdb_SubscribeType>(RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS + 1), &observer1);
1480 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1481
1482 Rdb_DataObserver observer2 = { nullptr, { nullptr } };
1483 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2);
1484 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1485 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, nullptr);
1486 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1487
1488 errCode = OH_Rdb_Unsubscribe(nullptr, static_cast<Rdb_SubscribeType>(RDB_SUBSCRIBE_TYPE_CLOUD - 1), &observer1);
1489 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1490 errCode =
1491 OH_Rdb_Unsubscribe(nullptr, static_cast<Rdb_SubscribeType>(RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS + 1), &observer1);
1492 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1493 }
1494