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 "oh_data_value.h"
24 #include "rdb_errno.h"
25 #include "relational_store.h"
26 #include "relational_store_error_code.h"
27 #include "relational_store_impl.h"
28 #include "token_setproc.h"
29
30 using namespace testing::ext;
31 using namespace OHOS::NativeRdb;
32 using namespace OHOS::Security::AccessToken;
33 using namespace OHOS::RdbNdk;
34
35 class RdbNativeStoreTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 void SetUp();
40 void TearDown();
InitRdbConfig()41 static void InitRdbConfig()
42 {
43 config_.dataBaseDir = RDB_TEST_PATH;
44 config_.storeName = "rdb_store_test.db";
45 config_.bundleName = "com.ohos.example.distributedndk";
46 config_.moduleName = "";
47 config_.securityLevel = OH_Rdb_SecurityLevel::S1;
48 config_.isEncrypt = false;
49 config_.selfSize = sizeof(OH_Rdb_Config);
50 config_.area = RDB_SECURITY_AREA_EL1;
51 }
52 static OH_Rdb_Config config_;
53 static void MockHap(void);
54 };
55
56 OH_Rdb_Store *storeTestRdbStore_;
57 OH_Rdb_Config RdbNativeStoreTest::config_ = { 0 };
58
MockHap(void)59 void RdbNativeStoreTest::MockHap(void)
60 {
61 HapInfoParams info = {
62 .userID = 100, .bundleName = "com.example.distributed", .instIndex = 0, .appIDDesc = "com.example.distributed"
63 };
64 PermissionDef infoManagerTestPermDef = { .permissionName = "ohos.permission.test",
65 .bundleName = "com.example.distributed",
66 .grantMode = 1,
67 .availableLevel = APL_NORMAL,
68 .label = "label",
69 .labelId = 1,
70 .description = "open the door",
71 .descriptionId = 1 };
72 PermissionStateFull infoManagerTestState = { .permissionName = "ohos.permission.test",
73 .isGeneral = true,
74 .resDeviceID = { "local" },
75 .grantStatus = { PermissionState::PERMISSION_GRANTED },
76 .grantFlags = { 1 } };
77 HapPolicyParams policy = { .apl = APL_NORMAL,
78 .domain = "test.domain",
79 .permList = { infoManagerTestPermDef },
80 .permStateList = { infoManagerTestState } };
81 AccessTokenKit::AllocHapToken(info, policy);
82 }
83
SetUpTestCase(void)84 void RdbNativeStoreTest::SetUpTestCase(void)
85 {
86 MockHap();
87 InitRdbConfig();
88 mkdir(config_.dataBaseDir, 0770);
89 int errCode = 0;
90 storeTestRdbStore_ = OH_Rdb_GetOrOpen(&config_, &errCode);
91 EXPECT_NE(storeTestRdbStore_, NULL);
92 }
93
TearDownTestCase(void)94 void RdbNativeStoreTest::TearDownTestCase(void)
95 {
96 int errCode = OH_Rdb_CloseStore(storeTestRdbStore_);
97 EXPECT_EQ(errCode, 0);
98 errCode = OH_Rdb_DeleteStore(&config_);
99 EXPECT_EQ(errCode, 0);
100 }
101
SetUp(void)102 void RdbNativeStoreTest::SetUp(void)
103 {
104 char createTableSql[] = "CREATE TABLE store_test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
105 "data3 FLOAT, data4 BLOB, data5 TEXT);";
106 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
107 EXPECT_EQ(errCode, 0);
108
109 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
110 valueBucket->putInt64(valueBucket, "id", 1);
111 valueBucket->putText(valueBucket, "data1", "zhangSan");
112 valueBucket->putInt64(valueBucket, "data2", 12800);
113 valueBucket->putReal(valueBucket, "data3", 100.1);
114 uint8_t arr[] = { 1, 2, 3, 4, 5 };
115 int len = sizeof(arr) / sizeof(arr[0]);
116 valueBucket->putBlob(valueBucket, "data4", arr, len);
117 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
118 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
119 EXPECT_EQ(errCode, 1);
120
121 char querySql[] = "SELECT * FROM store_test";
122 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
123
124 int rowCount = 0;
125 cursor->getRowCount(cursor, &rowCount);
126 EXPECT_EQ(rowCount, 1);
127 cursor->destroy(cursor);
128 valueBucket->destroy(valueBucket);
129 }
130
TearDown(void)131 void RdbNativeStoreTest::TearDown(void)
132 {
133 char dropTableSql[] = "DROP TABLE IF EXISTS store_test";
134 int errCode = OH_Rdb_Execute(storeTestRdbStore_, dropTableSql);
135 EXPECT_EQ(errCode, 0);
136 }
137
CloudSyncObserverCallback(void * context,Rdb_ProgressDetails * progressDetails)138 void CloudSyncObserverCallback(void *context, Rdb_ProgressDetails *progressDetails)
139 {
140 EXPECT_NE(progressDetails, nullptr);
141 EXPECT_EQ(progressDetails->version, DISTRIBUTED_PROGRESS_DETAIL_VERSION);
142 EXPECT_EQ(progressDetails->schedule, Rdb_Progress::RDB_SYNC_FINISH);
143 EXPECT_EQ(progressDetails->code, Rdb_ProgressCode::RDB_CLOUD_DISABLED);
144 EXPECT_EQ(progressDetails->tableLength, 0);
145 Rdb_TableDetails *tableDetails = OH_Rdb_GetTableDetails(progressDetails, DISTRIBUTED_PROGRESS_DETAIL_VERSION);
146 EXPECT_NE(tableDetails, nullptr);
147 }
148
CloudSyncCallback(Rdb_ProgressDetails * progressDetails)149 void CloudSyncCallback(Rdb_ProgressDetails *progressDetails)
150 {
151 CloudSyncObserverCallback(nullptr, progressDetails);
152 }
153
154 Rdb_ProgressCallback callback = CloudSyncObserverCallback;
155 Rdb_ProgressObserver observer = { nullptr, callback };
156
157 /**
158 * @tc.name: RDB_Native_store_test_001
159 * @tc.desc: Normal testCase of store for Update、Query.
160 * @tc.type: FUNC
161 */
162 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_001, TestSize.Level1)
163 {
164 int errCode = 0;
165 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
166 valueBucket->putText(valueBucket, "data1", "liSi");
167 valueBucket->putInt64(valueBucket, "data2", 13800);
168 valueBucket->putReal(valueBucket, "data3", 200.1);
169 valueBucket->putNull(valueBucket, "data5");
170
171 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
172 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
173 const char *data1Value = "zhangSan";
174 valueObject->putText(valueObject, data1Value);
175 predicates->equalTo(predicates, "data1", valueObject);
176 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
177 EXPECT_EQ(errCode, 1);
178
179 predicates->clear(predicates);
180 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
181 EXPECT_NE(cursor, NULL);
182
183 int rowCount = 0;
184 cursor->getRowCount(cursor, &rowCount);
185 EXPECT_EQ(rowCount, 1);
186
187 errCode = cursor->goToNextRow(cursor);
188 EXPECT_EQ(errCode, 0);
189
190 size_t size = 0;
191 cursor->getSize(cursor, 1, &size);
192 EXPECT_EQ(size, 5);
193 char data1Value1[size];
194 cursor->getText(cursor, 1, data1Value1, size);
195 EXPECT_EQ(strcmp(data1Value1, "liSi"), 0);
196
197 int64_t data2Value;
198 cursor->getInt64(cursor, 2, &data2Value);
199 EXPECT_EQ(data2Value, 13800);
200
201 double data3Value;
202 cursor->getReal(cursor, 3, &data3Value);
203 EXPECT_EQ(data3Value, 200.1);
204
205 cursor->getSize(cursor, 4, &size);
206 unsigned char data4Value[size];
207 cursor->getBlob(cursor, 4, data4Value, size);
208 EXPECT_EQ(data4Value[0], 1);
209 EXPECT_EQ(data4Value[1], 2);
210
211 bool isNull = false;
212 cursor->isNull(cursor, 5, &isNull);
213 EXPECT_EQ(isNull, true);
214
215 valueObject->destroy(valueObject);
216 valueBucket->destroy(valueBucket);
217 predicates->destroy(predicates);
218 cursor->destroy(cursor);
219 }
220
221 /**
222 * @tc.name: RDB_Native_store_test_002
223 * @tc.desc: Normal testCase of store for Delete、ExecuteQuery.
224 * @tc.type: FUNC
225 */
226 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_002, TestSize.Level1)
227 {
228 int errCode = 0;
229 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
230 valueBucket->putInt64(valueBucket, "id", 2);
231 valueBucket->putText(valueBucket, "data1", "liSi");
232 valueBucket->putInt64(valueBucket, "data2", 13800);
233 valueBucket->putReal(valueBucket, "data3", 200.1);
234 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
235 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
236 EXPECT_EQ(errCode, 2);
237
238 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
239 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
240 const char *data1Value = "zhangSan";
241 valueObject->putText(valueObject, data1Value);
242 predicates->equalTo(predicates, "data1", valueObject);
243 errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates);
244 EXPECT_EQ(errCode, 1);
245
246 char querySql[] = "SELECT * FROM store_test";
247 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
248
249 int rowCount = 0;
250 cursor->getRowCount(cursor, &rowCount);
251 EXPECT_EQ(rowCount, 1);
252
253 errCode = cursor->goToNextRow(cursor);
254 EXPECT_EQ(errCode, 0);
255
256 size_t size = 0;
257 cursor->getSize(cursor, 1, &size);
258 EXPECT_EQ(size, 5);
259 char data1Value1[size];
260 cursor->getText(cursor, 1, data1Value1, size);
261 EXPECT_EQ(strcmp(data1Value1, "liSi"), 0);
262
263 int64_t data2Value;
264 cursor->getInt64(cursor, 2, &data2Value);
265 EXPECT_EQ(data2Value, 13800);
266
267 double data3Value;
268 cursor->getReal(cursor, 3, &data3Value);
269 EXPECT_EQ(data3Value, 200.1);
270
271 bool isNull = false;
272 cursor->isNull(cursor, 4, &isNull);
273 EXPECT_EQ(isNull, true);
274
275 cursor->getSize(cursor, 5, &size);
276 char data5Value[size];
277 cursor->getText(cursor, 5, data5Value, size);
278 EXPECT_EQ(strcmp(data5Value, "ABCDEFGH"), 0);
279
280 valueObject->destroy(valueObject);
281 valueBucket->destroy(valueBucket);
282 predicates->destroy(predicates);
283 cursor->destroy(cursor);
284 }
285
286 /**
287 * @tc.name: RDB_Native_store_test_003
288 * @tc.desc: Normal testCase of store for Transaction、Commit.
289 * @tc.type: FUNC
290 */
291 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_003, TestSize.Level1)
292 {
293 OH_Rdb_BeginTransaction(storeTestRdbStore_);
294
295 int errCode = 0;
296 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
297 valueBucket->putInt64(valueBucket, "id", 2);
298 valueBucket->putText(valueBucket, "data1", "liSi");
299 valueBucket->putInt64(valueBucket, "data2", 13800);
300 valueBucket->putReal(valueBucket, "data3", 200.1);
301 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
302 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
303 EXPECT_EQ(errCode, 2);
304
305 OH_Rdb_Commit(storeTestRdbStore_);
306
307 char querySql[] = "SELECT * FROM store_test";
308 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
309
310 int rowCount = 0;
311 cursor->getRowCount(cursor, &rowCount);
312 EXPECT_EQ(rowCount, 2);
313
314 valueBucket->destroy(valueBucket);
315 cursor->destroy(cursor);
316 }
317
318 /**
319 * @tc.name: RDB_Native_store_test_004
320 * @tc.desc: Normal testCase of store for Transaction、RollBack.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_004, TestSize.Level1)
324 {
325 OH_Rdb_BeginTransaction(storeTestRdbStore_);
326
327 int errCode = 0;
328 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
329 valueBucket->putInt64(valueBucket, "id", 2);
330 valueBucket->putText(valueBucket, "data1", "liSi");
331 valueBucket->putInt64(valueBucket, "data2", 13800);
332 valueBucket->putReal(valueBucket, "data3", 200.1);
333 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
334 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
335 EXPECT_EQ(errCode, 2);
336
337 OH_Rdb_RollBack(storeTestRdbStore_);
338
339 char querySql[] = "SELECT * FROM store_test";
340 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
341
342 int rowCount = 0;
343 cursor->getRowCount(cursor, &rowCount);
344 EXPECT_EQ(rowCount, 1); // 回退至函数之前的状态
345
346 valueBucket->destroy(valueBucket);
347 cursor->destroy(cursor);
348 }
349
350 /**
351 * @tc.name: RDB_Native_store_test_005
352 * @tc.desc: Normal testCase of store for Backup、Restore.
353 * @tc.type: FUNC
354 */
355 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_005, TestSize.Level1)
356 {
357 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
358 valueBucket->putText(valueBucket, "data1", "zhangSan");
359 valueBucket->putInt64(valueBucket, "data2", 12800);
360 valueBucket->putReal(valueBucket, "data3", 100.1);
361
362 std::string backupPath1 = RDB_TEST_PATH + std::string("a.db");
363 int errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath1.c_str());
364 EXPECT_EQ(errCode, 0);
365
366 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
367 EXPECT_EQ(errCode, 2);
368 std::string backupPath2 = RDB_TEST_PATH + std::string("b.db");
369 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath2.c_str());
370 EXPECT_EQ(errCode, 0);
371
372 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
373 EXPECT_EQ(errCode, 3);
374 std::string backupPath3 = RDB_TEST_PATH + std::string("c.db");
375 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath3.c_str());
376 EXPECT_EQ(errCode, 0);
377
378 // Continuous backup
379 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
380 EXPECT_EQ(errCode, 4);
381 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath3.c_str());
382 EXPECT_EQ(errCode, 0);
383
384 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath1.c_str());
385 EXPECT_EQ(errCode, 0);
386 char querySql[] = "SELECT * FROM store_test";
387 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
388 int rowCount = 0;
389 cursor->getRowCount(cursor, &rowCount);
390 EXPECT_EQ(rowCount, 1);
391 cursor->destroy(cursor);
392
393 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath2.c_str());
394 EXPECT_EQ(errCode, 0);
395 cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
396 cursor->getRowCount(cursor, &rowCount);
397 EXPECT_EQ(rowCount, 2);
398 cursor->destroy(cursor);
399
400 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath3.c_str());
401 EXPECT_EQ(errCode, 0);
402 cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
403 cursor->getRowCount(cursor, &rowCount);
404 EXPECT_EQ(rowCount, 4);
405 cursor->destroy(cursor);
406
407 // Continuous restore
408 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath3.c_str());
409 EXPECT_EQ(errCode, 0);
410 cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
411 cursor->getRowCount(cursor, &rowCount);
412 EXPECT_EQ(rowCount, 4);
413
414 valueBucket->destroy(valueBucket);
415 cursor->destroy(cursor);
416 }
417
418 /**
419 * @tc.name: RDB_Native_store_test_006
420 * @tc.desc: Normal testCase of store for Backup、Restore.
421 * @tc.type: FUNC
422 */
423 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_006, TestSize.Level1)
424 {
425 int errCode = 0;
426 char querySql[] = "SELECT * FROM store_test";
427 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
428
429 int rowCount = 0;
430 cursor->getRowCount(cursor, &rowCount);
431 EXPECT_EQ(rowCount, 1);
432 cursor->destroy(cursor);
433
434 std::string backupPath = "backup.db";
435 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
436 EXPECT_EQ(errCode, 0);
437 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath.c_str());
438 EXPECT_EQ(errCode, 0);
439 cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
440 cursor->getRowCount(cursor, &rowCount);
441 EXPECT_EQ(rowCount, 1);
442 cursor->destroy(cursor);
443
444 std::string restorePath = "error.db";
445 errCode = OH_Rdb_Restore(storeTestRdbStore_, restorePath.c_str());
446 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
447 }
448
449 /**
450 * @tc.name: RDB_Native_store_test_007
451 * @tc.desc: Normal testCase of store for Backup、Restore.
452 * @tc.type: FUNC
453 */
454 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_007, TestSize.Level1)
455 {
456 int errCode = 0;
457 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
458 valueBucket->putText(valueBucket, "data1", "zhangSan");
459 valueBucket->putInt64(valueBucket, "data2", 12800);
460 valueBucket->putReal(valueBucket, "data3", 100.1);
461 uint8_t arr[] = { 1, 2, 3, 4, 5 };
462 int len = sizeof(arr) / sizeof(arr[0]);
463 valueBucket->putBlob(valueBucket, "data4", arr, len);
464 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
465
466 errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
467 EXPECT_EQ(errCode, 2);
468 std::string backupPath = " ";
469 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
470 EXPECT_EQ(errCode, 0);
471 errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath.c_str());
472 EXPECT_EQ(errCode, 0);
473 char querySql[] = "SELECT * FROM store_test";
474 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
475
476 int rowCount = 0;
477 cursor->getRowCount(cursor, &rowCount);
478 EXPECT_EQ(rowCount, 2);
479 cursor->destroy(cursor);
480
481 backupPath = "";
482 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
483 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
484
485 backupPath = RDB_TEST_PATH + std::string("/backup/backup.db");
486 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
487 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
488
489 backupPath = RDB_TEST_PATH;
490 errCode = OH_Rdb_Backup(storeTestRdbStore_, backupPath.c_str());
491 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
492
493 std::string restorePath = RDB_TEST_PATH;
494 errCode = OH_Rdb_Restore(storeTestRdbStore_, restorePath.c_str());
495 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
496
497 valueBucket->destroy(valueBucket);
498 }
499
500 /**
501 * @tc.name: RDB_Native_store_test_008
502 * @tc.desc: Normal testCase of store for GetVersion、SetVersion.
503 * @tc.type: FUNC
504 */
505 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_008, TestSize.Level1)
506 {
507 int errCode = 0;
508 int version = 0;
509 int setVersion = 3;
510 errCode = OH_Rdb_GetVersion(storeTestRdbStore_, &version);
511 EXPECT_EQ(errCode, 0);
512 EXPECT_EQ(version, 0);
513
514 errCode = OH_Rdb_SetVersion(storeTestRdbStore_, setVersion);
515 errCode = OH_Rdb_GetVersion(storeTestRdbStore_, &version);
516 EXPECT_EQ(errCode, 0);
517 EXPECT_EQ(version, 3);
518 }
519
520 /**
521 * @tc.name: RDB_Native_store_test_009
522 * @tc.desc: Normal testCase of store for Insert with wrong table name or table is NULL.
523 * @tc.type: FUNC
524 */
525 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_009, TestSize.Level1)
526 {
527 int errCode = 0;
528 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
529 valueBucket->putInt64(valueBucket, "id", 2);
530 valueBucket->putText(valueBucket, "data1", "liSi");
531 valueBucket->putInt64(valueBucket, "data2", 13800);
532 valueBucket->putReal(valueBucket, "data3", 200.1);
533 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
534 errCode = OH_Rdb_Insert(storeTestRdbStore_, "wrong", valueBucket);
535 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_ERR);
536
537 valueBucket->clear(valueBucket);
538 valueBucket->putInt64(valueBucket, "id", 3);
539 valueBucket->putText(valueBucket, "data1", "wangWu");
540 valueBucket->putInt64(valueBucket, "data2", 14800);
541 valueBucket->putReal(valueBucket, "data3", 300.1);
542 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
543 char *table = NULL;
544 errCode = OH_Rdb_Insert(storeTestRdbStore_, table, valueBucket);
545 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
546 errCode = OH_Rdb_Insert(nullptr, "wrong", valueBucket);
547 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
548 errCode = OH_Rdb_Insert(storeTestRdbStore_, "wrong", nullptr);
549 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
550
551 char querySql[] = "SELECT * FROM store_test";
552 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
553
554 int rowCount = 0;
555 cursor->getRowCount(cursor, &rowCount);
556 EXPECT_EQ(rowCount, 1);
557
558 valueBucket->destroy(valueBucket);
559 cursor->destroy(cursor);
560 }
561
562 /**
563 * @tc.name: RDB_Native_store_test_0010
564 * @tc.desc: Normal testCase of store for Update with wrong table or table is NULL.
565 * @tc.type: FUNC
566 */
567 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_0010, TestSize.Level1)
568 {
569 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
570 valueBucket->putText(valueBucket, "data1", "liSi");
571 valueBucket->putInt64(valueBucket, "data2", 13800);
572
573 OH_Predicates *predicates = OH_Rdb_CreatePredicates("wrong");
574 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
575 const char *data1Value = "zhangSan";
576 valueObject->putText(valueObject, data1Value);
577 predicates->equalTo(predicates, "data1", valueObject);
578 int errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
579 EXPECT_EQ(errCode, -1);
580
581 char *table = NULL;
582 OH_Predicates *predicates1 = OH_Rdb_CreatePredicates(table);
583 EXPECT_EQ(predicates1, NULL);
584 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates1);
585 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
586 errCode = OH_Rdb_Update(nullptr, valueBucket, predicates);
587 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
588 errCode = OH_Rdb_Update(storeTestRdbStore_, nullptr, predicates);
589 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
590
591 OH_Predicates *predicates2 = OH_Rdb_CreatePredicates("store_test");
592 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates2, NULL, 0);
593 EXPECT_NE(cursor, NULL);
594
595 int rowCount = 0;
596 cursor->getRowCount(cursor, &rowCount);
597 EXPECT_EQ(rowCount, 1);
598
599 errCode = cursor->goToNextRow(cursor);
600 EXPECT_EQ(errCode, 0);
601
602 size_t size = 0;
603 cursor->getSize(cursor, 1, &size);
604 char data1Value1[size];
605 cursor->getText(cursor, 1, data1Value1, size);
606 EXPECT_EQ(strcmp(data1Value1, "zhangSan"), 0);
607
608 int64_t data2Value;
609 cursor->getInt64(cursor, 2, &data2Value);
610 EXPECT_EQ(data2Value, 12800);
611
612 double data3Value;
613 cursor->getReal(cursor, 3, &data3Value);
614 EXPECT_EQ(data3Value, 100.1);
615
616 cursor->getSize(cursor, 4, &size);
617 unsigned char data4Value[size];
618 cursor->getBlob(cursor, 4, data4Value, size);
619 EXPECT_EQ(data4Value[0], 1);
620 EXPECT_EQ(data4Value[1], 2);
621
622 valueObject->destroy(valueObject);
623 predicates->destroy(predicates);
624 predicates2->destroy(predicates2);
625 valueBucket->destroy(valueBucket);
626 cursor->destroy(cursor);
627 }
628
629 /**
630 * @tc.name: RDB_Native_store_test_011
631 * @tc.desc: Abnormal testCase of store for Query.
632 * @tc.type: FUNC
633 */
634 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_011, TestSize.Level1)
635 {
636 char *querySql = NULL;
637 // sql is nullptr
638 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
639 EXPECT_EQ(cursor, NULL);
640 // store is nullptr
641 cursor = OH_Rdb_ExecuteQuery(nullptr, querySql);
642 EXPECT_EQ(cursor, NULL);
643
644 // store is nullptr
645 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
646 cursor = OH_Rdb_Query(nullptr, predicates, NULL, 0);
647 EXPECT_EQ(cursor, NULL);
648 }
649
650 /**
651 * @tc.name: RDB_Native_store_test_012
652 * @tc.desc: Normal testCase of RelationalValuesBucket for anomalous branch.
653 * @tc.type: FUNC
654 */
655 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_012, TestSize.Level1)
656 {
657 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
658 uint8_t arr[] = { 1, 2, 3, 4, 5 };
659 uint32_t len = sizeof(arr) / sizeof(arr[0]);
660 int errCode = valueBucket->putBlob(nullptr, "data4", arr, len);
661 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
662 errCode = valueBucket->putBlob(valueBucket, nullptr, arr, len);
663 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
664 errCode = valueBucket->putBlob(valueBucket, "data4", nullptr, len);
665 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_OK);
666
667 errCode = valueBucket->clear(nullptr);
668 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
669 errCode = valueBucket->destroy(nullptr);
670 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
671 valueBucket->destroy(valueBucket);
672 }
673
674 /**
675 * @tc.name: RDB_Native_store_test_013
676 * @tc.desc: Normal testCase of store for CloudSync.
677 * @tc.type: FUNC
678 */
679 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_013, TestSize.Level1)
680 {
681 EXPECT_NE(storeTestRdbStore_, nullptr);
682 constexpr int TABLE_COUNT = 1;
683 const char *table[TABLE_COUNT];
684 table[0] = "store_test";
685 Rdb_ProgressObserver observer;
686 void *context = nullptr;
687 observer.context = &context;
688 observer.callback = CloudSyncObserverCallback;
689 auto errorCode =
690 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_TIME_FIRST, table, TABLE_COUNT, &observer);
691 EXPECT_EQ(errorCode, RDB_OK);
692
693 errorCode =
694 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_CLOUD_FIRST, table, TABLE_COUNT, &observer);
695 EXPECT_EQ(errorCode, RDB_OK);
696
697 errorCode =
698 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_NATIVE_FIRST, table, TABLE_COUNT, &observer);
699 EXPECT_EQ(errorCode, RDB_OK);
700
701 errorCode =
702 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_NATIVE_FIRST, table, TABLE_COUNT, nullptr);
703 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
704 }
705
706 /**
707 * @tc.name: RDB_Native_store_test_014
708 * @tc.desc: Abnormal testCase of store for SetDistributedTables.
709 * @tc.type: FUNC
710 */
711 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_014, TestSize.Level1)
712 {
713 EXPECT_NE(storeTestRdbStore_, nullptr);
714 Rdb_DistributedConfig config{ .version = 0, .isAutoSync = true };
715 constexpr int TABLE_COUNT = 1;
716 const char *table[TABLE_COUNT];
717 table[0] = "store_test";
718 int errcode = OH_Rdb_SetDistributedTables(
719 storeTestRdbStore_, table, TABLE_COUNT, Rdb_DistributedType::RDB_DISTRIBUTED_CLOUD, &config);
720 EXPECT_EQ(errcode, RDB_E_INVALID_ARGS);
721 config.version = DISTRIBUTED_CONFIG_VERSION;
722 errcode =
723 OH_Rdb_SetDistributedTables(nullptr, table, TABLE_COUNT, Rdb_DistributedType::RDB_DISTRIBUTED_CLOUD, &config);
724 EXPECT_EQ(errcode, RDB_E_INVALID_ARGS);
725 }
726
727 /**
728 * @tc.name: RDB_Native_store_test_015
729 * @tc.desc: Normal testCase of store for CloudSync.
730 * @tc.type: FUNC
731 */
732 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_015, TestSize.Level1)
733 {
734 EXPECT_NE(storeTestRdbStore_, nullptr);
735 constexpr int TABLE_COUNT = 1;
736 const char *table[TABLE_COUNT];
737 table[0] = "store_test";
738 Rdb_ProgressObserver observer;
739 void *context = nullptr;
740 observer.context = context;
741 observer.callback = CloudSyncObserverCallback;
742 auto errorCode =
743 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_TIME_FIRST, table, TABLE_COUNT, &observer);
744 EXPECT_EQ(errorCode, RDB_OK);
745
746 errorCode =
747 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_CLOUD_FIRST, table, TABLE_COUNT, &observer);
748 EXPECT_EQ(errorCode, RDB_OK);
749
750 errorCode =
751 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_NATIVE_FIRST, table, TABLE_COUNT, &observer);
752 EXPECT_EQ(errorCode, RDB_OK);
753 }
754
755 /**
756 * @tc.name: RDB_Native_store_test_016
757 * @tc.desc: Abnormal testCase of store for CloudSync.
758 * @tc.type: FUNC
759 */
760 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_016, TestSize.Level1)
761 {
762 EXPECT_NE(storeTestRdbStore_, nullptr);
763 constexpr int TABLE_COUNT = 1;
764 const char *table[TABLE_COUNT];
765 table[0] = "store_test";
766 Rdb_ProgressObserver observer;
767 void *context = nullptr;
768 observer.context = context;
769 observer.callback = CloudSyncObserverCallback;
770 auto errorCode =
771 OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_TIME_FIRST, table, TABLE_COUNT, nullptr);
772 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
773 errorCode = OH_Rdb_CloudSync(nullptr, Rdb_SyncMode::RDB_SYNC_MODE_CLOUD_FIRST, table, TABLE_COUNT, &observer);
774 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
775 }
776
777 /**
778 * @tc.name: RDB_Native_store_test_017
779 * @tc.desc: Normal testCase for GetModifyTime.
780 * @tc.type: FUNC
781 */
782 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_017, TestSize.Level1)
783 {
784 char createLogTableSql[] = "CREATE TABLE if not exists naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
785 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
786 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);";
787 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createLogTableSql);
788 EXPECT_EQ(errCode, RDB_OK);
789 OH_VBucket *bucket = OH_Rdb_CreateValuesBucket();
790 bucket->putInt64(bucket, "data_key", 1);
791 bucket->putInt64(bucket, "timestamp", 1000000000);
792 errCode = OH_Rdb_Insert(storeTestRdbStore_, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", bucket);
793 EXPECT_EQ(errCode, 1);
794
795 OH_VObject *values = OH_Rdb_CreateValueObject();
796 int64_t keys[] = { 1 };
797 values->putInt64(values, keys, 1);
798
799 OH_Cursor *cursor;
800 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdbstoreimpltest_integer", "ROWID", values);
801 int rowCount;
802 errCode = cursor->getRowCount(cursor, &rowCount);
803 EXPECT_EQ(errCode, RDB_OK);
804 EXPECT_EQ(rowCount, 1);
805 cursor->goToNextRow(cursor);
806 int64_t key = 0;
807 cursor->getInt64(cursor, 0, &key);
808 EXPECT_EQ(key, 1);
809 int64_t time = 0;
810 cursor->getInt64(cursor, 1, &time);
811 EXPECT_EQ(time, 100000);
812
813 cursor->destroy(cursor);
814 char dropLogTableSql[] = "DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log";
815 errCode = OH_Rdb_Execute(storeTestRdbStore_, dropLogTableSql);
816 EXPECT_EQ(errCode, RDB_OK);
817 }
818
819 /**
820 * @tc.name: RDB_Native_store_test_018
821 * @tc.desc: Abnormal testCase for GetModifyTime, tablename columnName, keys is empty,
822 * and resultSet is null or empty
823 * @tc.type: FUNC
824 */
825 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_018, TestSize.Level1)
826 {
827 char createLogTableSql[] = "CREATE TABLE if not exists naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
828 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
829 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);";
830 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createLogTableSql);
831 EXPECT_EQ(errCode, RDB_OK);
832 OH_VBucket *bucket = OH_Rdb_CreateValuesBucket();
833 bucket->putInt64(bucket, "data_key", 1);
834 bucket->putInt64(bucket, "timestamp", 1000000000);
835 errCode = OH_Rdb_Insert(storeTestRdbStore_, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", bucket);
836 EXPECT_EQ(errCode, 1);
837
838 OH_VObject *values = OH_Rdb_CreateValueObject();
839 int64_t keys[] = { 1 };
840 values->putInt64(values, keys, 1);
841
842 // store is nullptr
843 OH_Cursor *cursor = OH_Rdb_FindModifyTime(nullptr, "rdbstoreimpltest_integer", "data_key", values);
844 EXPECT_EQ(cursor, nullptr);
845
846 // tabel name is nullptr
847 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, nullptr, "data_key", values);
848 EXPECT_EQ(cursor, nullptr);
849
850 // key is nullptr
851 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdbstoreimpltest_integer", "data_key", nullptr);
852 EXPECT_EQ(cursor, nullptr);
853
854 // table name is ""
855 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "", "data_key", values);
856 int rowCount = 0;
857 errCode = cursor->getRowCount(cursor, &rowCount);
858 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
859
860 // table name is not exist , resultSet is null
861 cursor->destroy(cursor);
862 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "test", "data_key", values);
863 cursor->getRowCount(cursor, &rowCount);
864 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
865
866 // columnName is ""
867 cursor->destroy(cursor);
868 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdbstoreimpltest_integer", "", values);
869 cursor->getRowCount(cursor, &rowCount);
870 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
871
872 // keys is empty
873 cursor->destroy(cursor);
874 OH_VObject *emptyValues = OH_Rdb_CreateValueObject();
875 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdb_aux_rdbstoreimpltest_integer", "data_key", emptyValues);
876 cursor->getRowCount(cursor, &rowCount);
877 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
878
879 cursor->destroy(cursor);
880 char dropLogTableSql[] = "DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log";
881 errCode = OH_Rdb_Execute(storeTestRdbStore_, dropLogTableSql);
882 EXPECT_EQ(errCode, RDB_OK);
883 }
884
885 /**
886 * @tc.name: RDB_Native_store_test_019
887 * @tc.desc: testCase for OH_Rdb_SubscribeAutoSyncProgress test.
888 * @tc.type: FUNC
889 */
890 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_019, TestSize.Level1)
891 {
892 EXPECT_NE(storeTestRdbStore_, nullptr);
893 EXPECT_EQ(OH_Rdb_SubscribeAutoSyncProgress(storeTestRdbStore_, &observer), RDB_OK);
894 EXPECT_EQ(OH_Rdb_SubscribeAutoSyncProgress(storeTestRdbStore_, &observer), RDB_OK);
895 EXPECT_EQ(OH_Rdb_SubscribeAutoSyncProgress(storeTestRdbStore_, nullptr), RDB_E_INVALID_ARGS);
896 EXPECT_EQ(OH_Rdb_SubscribeAutoSyncProgress(nullptr, &observer), RDB_E_INVALID_ARGS);
897 }
898
899 /**
900 * @tc.name: RDB_Native_store_test_020
901 * @tc.desc: testCase for OH_Rdb_UnsubscribeAutoSyncProgress test.
902 * @tc.type: FUNC
903 */
904 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_020, TestSize.Level1)
905 {
906 EXPECT_NE(storeTestRdbStore_, nullptr);
907 EXPECT_EQ(OH_Rdb_UnsubscribeAutoSyncProgress(storeTestRdbStore_, &observer), RDB_OK);
908 EXPECT_EQ(OH_Rdb_UnsubscribeAutoSyncProgress(storeTestRdbStore_, &observer), RDB_OK);
909 EXPECT_EQ(OH_Rdb_UnsubscribeAutoSyncProgress(storeTestRdbStore_, nullptr), RDB_OK);
910 EXPECT_EQ(OH_Rdb_UnsubscribeAutoSyncProgress(nullptr, &observer), RDB_E_INVALID_ARGS);
911 }
912
913 /**
914 * @tc.name: Abnormal_RDB_OH_interface_test_021
915 * @tc.desc: Abnormal testCase of store for OH interface.
916 * @tc.type: FUNC
917 */
918 HWTEST_F(RdbNativeStoreTest, Abnormal_RDB_OH_interface_test_021, TestSize.Level1)
919 {
920 OH_Rdb_Config config;
921 int errCode = E_OK;
922 OH_Rdb_Store *rdbStore;
923 rdbStore = OH_Rdb_GetOrOpen(nullptr, &errCode);
924 EXPECT_EQ(rdbStore, nullptr);
925 EXPECT_EQ(errCode, E_OK);
926
927 rdbStore = OH_Rdb_GetOrOpen(&config, nullptr);
928 EXPECT_EQ(rdbStore, nullptr);
929
930 config.selfSize = INT_MAX;
931 rdbStore = OH_Rdb_GetOrOpen(&config, nullptr);
932 EXPECT_EQ(rdbStore, nullptr);
933
934 config.dataBaseDir = RDB_TEST_PATH;
935 config.storeName = "rdb_store_abnormal_test.db";
936 config.bundleName = "com.example.distributed";
937 config.moduleName = "";
938 config.securityLevel = OH_Rdb_SecurityLevel::S1;
939 config.isEncrypt = false;
940 config.selfSize = sizeof(OH_Rdb_Config);
941 config.area = RDB_SECURITY_AREA_EL1;
942
943 errCode = 0;
944 errCode = OH_Rdb_DeleteStore(nullptr);
945 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
946
947 config.dataBaseDir = nullptr;
948 errCode = OH_Rdb_DeleteStore(&config);
949 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
950
951 config.dataBaseDir = RDB_TEST_PATH;
952 config.storeName = nullptr;
953 errCode = OH_Rdb_DeleteStore(&config);
954 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
955 }
956
957 /**
958 * @tc.name: Abnormal_RDB_OH_interface_test_022
959 * @tc.desc: Abnormal testCase of store for OH interface.
960 * @tc.type: FUNC
961 */
962 HWTEST_F(RdbNativeStoreTest, Abnormal_RDB_OH_interface_test_022, TestSize.Level1)
963 {
964 char createTableSql[] = "CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER);";
965 int errCode = OH_Rdb_Execute(nullptr, createTableSql);
966 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
967 errCode = OH_Rdb_Execute(storeTestRdbStore_, nullptr);
968 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
969
970 errCode = OH_Rdb_Backup(nullptr, RDB_TEST_PATH);
971 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
972 errCode = OH_Rdb_Backup(storeTestRdbStore_, nullptr);
973 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
974
975 errCode = OH_Rdb_BeginTransaction(nullptr);
976 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
977
978 errCode = OH_Rdb_Commit(nullptr);
979 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
980
981 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
982 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
983 const char *data1Value = "zhangSan";
984 valueObject->putText(valueObject, data1Value);
985 predicates->equalTo(predicates, "data1", valueObject);
986 errCode = OH_Rdb_Delete(nullptr, predicates);
987 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
988 errCode = OH_Rdb_Delete(storeTestRdbStore_, nullptr);
989 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
990
991 errCode = OH_Rdb_RollBack(nullptr);
992 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
993
994 errCode = OH_Rdb_Restore(nullptr, RDB_TEST_PATH);
995 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
996 errCode = OH_Rdb_Restore(storeTestRdbStore_, nullptr);
997 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
998
999 int version = 2;
1000 errCode = OH_Rdb_SetVersion(nullptr, version);
1001 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1002
1003 errCode = OH_Rdb_GetVersion(nullptr, &version);
1004 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1005 errCode = OH_Rdb_GetVersion(storeTestRdbStore_, nullptr);
1006 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1007
1008 errCode = OH_Rdb_CloseStore(nullptr);
1009 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
1010 }
1011
1012 /**
1013 * @tc.name: RDB_Native_store_test_023
1014 * @tc.desc: Normal testCase of store for Lock/Unlock and QueryLockedRow.
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_023, TestSize.Level1)
1018 {
1019 EXPECT_NE(storeTestRdbStore_, nullptr);
1020 char createTableSql[] = "CREATE TABLE lock_test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
1021 "data3 FLOAT, data4 BLOB, data5 TEXT);";
1022 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
1023 EXPECT_EQ(errCode, 0);
1024
1025 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1026 EXPECT_NE(valueBucket, nullptr);
1027 valueBucket->putInt64(valueBucket, "id", 1);
1028 valueBucket->putText(valueBucket, "data1", "wanger");
1029 valueBucket->putInt64(valueBucket, "data2", 12800);
1030 valueBucket->putReal(valueBucket, "data3", 100.1);
1031 uint8_t arr[] = { 1, 2, 3, 4, 5 };
1032 int len = sizeof(arr) / sizeof(arr[0]);
1033 valueBucket->putBlob(valueBucket, "data4", arr, len);
1034 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1035 errCode = OH_Rdb_Insert(storeTestRdbStore_, "lock_test", valueBucket);
1036 EXPECT_EQ(errCode, 1);
1037
1038 OH_Predicates *predicates = OH_Rdb_CreatePredicates("lock_test");
1039 EXPECT_NE(predicates, nullptr);
1040 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1041 EXPECT_NE(valueObject, nullptr);
1042 const char *data1Value = "wanger";
1043 valueObject->putText(valueObject, data1Value);
1044 predicates->equalTo(predicates, "data1", valueObject);
1045 errCode = OH_Rdb_LockRow(storeTestRdbStore_, predicates);
1046 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_NO_ROW_IN_QUERY);
1047
1048 predicates->clear(predicates);
1049 OH_Cursor *cursor = OH_Rdb_QueryLockedRow(storeTestRdbStore_, predicates, NULL, 0);
1050 EXPECT_NE(cursor, NULL);
1051
1052 int rowCount = 0;
1053 cursor->getRowCount(cursor, &rowCount);
1054 EXPECT_EQ(rowCount, -1);
1055
1056 predicates->clear(predicates);
1057 errCode = OH_Rdb_UnlockRow(storeTestRdbStore_, predicates);
1058 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_NO_ROW_IN_QUERY);
1059 cursor->destroy(cursor);
1060
1061 predicates->clear(predicates);
1062 cursor = OH_Rdb_QueryLockedRow(storeTestRdbStore_, predicates, NULL, 0);
1063 EXPECT_NE(cursor, NULL);
1064
1065 rowCount = 0;
1066 cursor->getRowCount(cursor, &rowCount);
1067 EXPECT_EQ(rowCount, -1);
1068
1069 valueObject->destroy(valueObject);
1070 valueBucket->destroy(valueBucket);
1071 predicates->destroy(predicates);
1072 cursor->destroy(cursor);
1073 }
1074
LocalDataChangeObserverCallback1(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1075 void LocalDataChangeObserverCallback1(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1076 {
1077 for (uint32_t i = 0; i < count; i++) {
1078 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1079 // 0 represent table name is store_test
1080 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "store_test"), 0);
1081 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1082 // insert row count is 1
1083 EXPECT_EQ(1, changeInfo[i]->inserted.count);
1084 EXPECT_EQ(TYPE_INT64, changeInfo[i]->inserted.type);
1085 // insert rowId is 2
1086 EXPECT_EQ(2, changeInfo[i]->inserted.data->integer);
1087 // update row count is 0
1088 EXPECT_EQ(0, changeInfo[i]->updated.count);
1089 // delete row count is 0
1090 EXPECT_EQ(0, changeInfo[i]->deleted.count);
1091 }
1092 }
1093
1094 /**
1095 * @tc.name: RDB_Native_store_test_024
1096 * @tc.desc: normal testCase for OH_Rdb_Subscribe, insert data into local database
1097 * @tc.type: FUNC
1098 */
1099 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_024, TestSize.Level1)
1100 {
1101 EXPECT_NE(storeTestRdbStore_, nullptr);
1102
1103 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback1;
1104 Rdb_DataObserver observer = { nullptr, { callback } };
1105 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1106
1107 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1108 // id is 2
1109 valueBucket->putInt64(valueBucket, "id", 2);
1110 valueBucket->putText(valueBucket, "data1", "zhangSan");
1111 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
1112 // insert rowId is 2
1113 EXPECT_EQ(2, errCode);
1114
1115 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1116 valueBucket->destroy(valueBucket);
1117 }
1118
LocalDataChangeObserverCallback2(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1119 void LocalDataChangeObserverCallback2(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1120 {
1121 for (uint32_t i = 0; i < count; i++) {
1122 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1123 // 0 represent table name is store_test
1124 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "store_test"), 0);
1125 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1126 EXPECT_EQ(TYPE_INT64, changeInfo[i]->updated.type);
1127 // update row count is 1
1128 EXPECT_EQ(1, changeInfo[i]->updated.count);
1129 // update rowId is 1
1130 EXPECT_EQ(1, changeInfo[i]->updated.data->integer);
1131 // insert row count is 0
1132 EXPECT_EQ(0, changeInfo[i]->inserted.count);
1133 // delete row count is 0
1134 EXPECT_EQ(0, changeInfo[i]->deleted.count);
1135 }
1136 }
1137
1138 /**
1139 * @tc.name: RDB_Native_store_test_025
1140 * @tc.desc: normal testCase for OH_Rdb_Subscribe, update a data into local database
1141 * @tc.type: FUNC
1142 */
1143 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_025, TestSize.Level1)
1144 {
1145 EXPECT_NE(storeTestRdbStore_, nullptr);
1146
1147 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback2;
1148 Rdb_DataObserver observer = { nullptr, { callback } };
1149
1150 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1151
1152 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1153 valueBucket->putText(valueBucket, "data1", "liSi");
1154
1155 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
1156 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1157 const char *data1Value = "zhangSan";
1158 valueObject->putText(valueObject, data1Value);
1159 predicates->equalTo(predicates, "data1", valueObject);
1160 int errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
1161 // update row count is 1
1162 EXPECT_EQ(errCode, 1);
1163
1164 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1165 valueObject->destroy(valueObject);
1166 valueBucket->destroy(valueBucket);
1167 predicates->destroy(predicates);
1168 }
1169
LocalDataChangeObserverCallback3(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1170 void LocalDataChangeObserverCallback3(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1171 {
1172 for (uint32_t i = 0; i < count; i++) {
1173 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1174 // 0 represent table name is 0
1175 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "store_test"), 0);
1176 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1177 EXPECT_EQ(TYPE_INT64, changeInfo[i]->deleted.type);
1178 // delete count is 1
1179 EXPECT_EQ(1, changeInfo[i]->deleted.count);
1180 // delete rowId is 1
1181 EXPECT_EQ(1, changeInfo[i]->deleted.data->integer);
1182 // insert count is 0
1183 EXPECT_EQ(0, changeInfo[i]->inserted.count);
1184 // update count is 0
1185 EXPECT_EQ(0, changeInfo[i]->updated.count);
1186 }
1187 }
1188
1189 /**
1190 * @tc.name: RDB_Native_store_test_026
1191 * @tc.desc: normal testCase for OH_Rdb_Subscribe, delete data into local database
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_026, TestSize.Level1)
1195 {
1196 EXPECT_NE(storeTestRdbStore_, nullptr);
1197
1198 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback3;
1199 Rdb_DataObserver observer = { nullptr, { callback } };
1200
1201 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1202
1203 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
1204 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1205 const char *data1Value = "zhangSan";
1206 valueObject->putText(valueObject, data1Value);
1207 predicates->equalTo(predicates, "data1", valueObject);
1208 int errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates);
1209 // delete row count is 1
1210 EXPECT_EQ(errCode, 1);
1211
1212 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1213 valueObject->destroy(valueObject);
1214 predicates->destroy(predicates);
1215 }
1216
1217 /**
1218 * @tc.name: RDB_Native_store_test_027
1219 * @tc.desc: normal testCase for OH_Rdb_Subscribe, register two observers for local database
1220 * @tc.type: FUNC
1221 */
1222 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_027, TestSize.Level1)
1223 {
1224 EXPECT_NE(storeTestRdbStore_, nullptr);
1225
1226 Rdb_DetailsObserver callback1 = LocalDataChangeObserverCallback1;
1227 Rdb_DataObserver observer1 = { nullptr, { callback1 } };
1228
1229 Rdb_DetailsObserver callback2 = LocalDataChangeObserverCallback1;
1230 Rdb_DataObserver observer2 = { nullptr, { callback2 } };
1231
1232 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1233 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1234
1235 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1236 // id is 2
1237 valueBucket->putInt64(valueBucket, "id", 2);
1238 valueBucket->putText(valueBucket, "data1", "zhangSan");
1239 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
1240 // rowId is 2
1241 EXPECT_EQ(2, errCode);
1242
1243 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1244 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1245 valueBucket->destroy(valueBucket);
1246 }
1247
LocalDataChangeObserverCallback4(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1248 void LocalDataChangeObserverCallback4(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1249 {
1250 EXPECT_EQ(0, count);
1251 }
1252
1253 /**
1254 * @tc.name: RDB_Native_store_test_028
1255 * @tc.desc: normal testCase for OH_Rdb_Subscribe.
1256 * 1.register two observers for local database
1257 * 2.unRegister one of observers
1258 * @tc.type: FUNC
1259 */
1260 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_028, TestSize.Level1)
1261 {
1262 EXPECT_NE(storeTestRdbStore_, nullptr);
1263
1264 Rdb_DetailsObserver callback1 = LocalDataChangeObserverCallback4;
1265 Rdb_DataObserver observer1 = { nullptr, { callback1 } };
1266
1267 Rdb_DetailsObserver callback2 = LocalDataChangeObserverCallback1;
1268 Rdb_DataObserver observer2 = { nullptr, { callback2 } };
1269
1270 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1271 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1272 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1273
1274 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1275 // id is 2
1276 valueBucket->putInt64(valueBucket, "id", 2);
1277 valueBucket->putText(valueBucket, "data1", "zhangSan");
1278 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
1279 // rowId is 2
1280 EXPECT_EQ(2, errCode);
1281
1282 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1283 valueBucket->destroy(valueBucket);
1284 }
1285
LocalDataChangeObserverCallback5(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1286 void LocalDataChangeObserverCallback5(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1287 {
1288 for (uint32_t i = 0; i < count; i++) {
1289 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1290 // 0 represent table name is test1
1291 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "test1"), 0);
1292 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1293 // insert a data
1294 EXPECT_EQ(1, changeInfo[i]->inserted.count);
1295 EXPECT_EQ(TYPE_INT64, changeInfo[i]->inserted.type);
1296 // insert rowId is 1
1297 EXPECT_EQ(1, changeInfo[i]->inserted.data->integer);
1298 // update count is 0
1299 EXPECT_EQ(0, changeInfo[i]->updated.count);
1300 // delete count is 0
1301 EXPECT_EQ(0, changeInfo[i]->deleted.count);
1302 }
1303 }
1304
1305 /**
1306 * @tc.name: RDB_Native_store_test_029
1307 * @tc.desc: normal testCase for OH_Rdb_Subscribe.
1308 * 1.register observer for local database
1309 * 2.create new table test
1310 * 3.insert data into table test
1311 * 2.unRegister one of observer
1312 * @tc.type: FUNC
1313 */
1314 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_029, TestSize.Level1)
1315 {
1316 EXPECT_NE(storeTestRdbStore_, nullptr);
1317
1318 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback5;
1319 Rdb_DataObserver observer = { nullptr, { callback } };
1320
1321 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1322
1323 constexpr const char *createTableSql = "CREATE TABLE test1 (id INTEGER PRIMARY KEY AUTOINCREMENT, "
1324 "data1 TEXT, data2 INTEGER, data3 FLOAT, data4 BLOB, data5 TEXT);";
1325 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
1326 // errCode is 0
1327 EXPECT_EQ(errCode, 0);
1328
1329 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1330 valueBucket->putInt64(valueBucket, "id", 1);
1331 valueBucket->putText(valueBucket, "data1", "zhangSan");
1332 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test1", valueBucket);
1333 // rowId is 1
1334 EXPECT_EQ(1, errCode);
1335
1336 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1337
1338 constexpr const char *dropTableSql = "DROP TABLE IF EXISTS test1";
1339 errCode = OH_Rdb_Execute(storeTestRdbStore_, dropTableSql);
1340 // errCode is 0
1341 EXPECT_EQ(errCode, 0);
1342 valueBucket->destroy(valueBucket);
1343 }
1344
LocalDataChangeObserverCallback6(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1345 void LocalDataChangeObserverCallback6(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1346 {
1347 for (uint32_t i = 0; i < count; i++) {
1348 EXPECT_EQ(DISTRIBUTED_CHANGE_INFO_VERSION, changeInfo[i]->version);
1349 // 0 represent table name is store_test
1350 EXPECT_EQ(strcmp(changeInfo[i]->tableName, "store_test"), 0);
1351 EXPECT_EQ(RDB_DATA_CHANGE, changeInfo[i]->ChangeType);
1352 // update row count is 2
1353 EXPECT_EQ(2, changeInfo[i]->updated.count);
1354 EXPECT_EQ(TYPE_INT64, changeInfo[i]->updated.type);
1355 // update rowId is 1
1356 EXPECT_EQ(1, changeInfo[i]->updated.data->integer);
1357 // update rowId is 2
1358 EXPECT_EQ(2, ++(changeInfo[i]->updated.data)->integer);
1359 // insert count is 0
1360 EXPECT_EQ(0, changeInfo[i]->inserted.count);
1361 // delete count is 0
1362 EXPECT_EQ(0, changeInfo[i]->deleted.count);
1363 }
1364 }
1365
1366 /**
1367 * @tc.name: RDB_Native_store_test_030
1368 * @tc.desc: normal testCase for OH_Rdb_Subscribe, update two data in local database
1369 * @tc.type: FUNC
1370 */
1371 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_030, TestSize.Level1)
1372 {
1373 EXPECT_NE(storeTestRdbStore_, nullptr);
1374
1375 OH_VBucket *valueBucket1 = OH_Rdb_CreateValuesBucket();
1376 valueBucket1->putText(valueBucket1, "data1", "zhangSan");
1377 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket1);
1378 // rowId is 2
1379 EXPECT_EQ(2, errCode);
1380
1381 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback6;
1382 Rdb_DataObserver observer = { nullptr, { callback } };
1383
1384 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1385
1386 OH_VBucket *valueBucket2 = OH_Rdb_CreateValuesBucket();
1387 valueBucket2->putText(valueBucket2, "data1", "liSi");
1388
1389 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
1390 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1391 const char *data1Value = "zhangSan";
1392 valueObject->putText(valueObject, data1Value);
1393 predicates->equalTo(predicates, "data1", valueObject);
1394 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket2, predicates);
1395 // update row count is 2
1396 EXPECT_EQ(errCode, 2);
1397
1398 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
1399 valueObject->destroy(valueObject);
1400 valueBucket1->destroy(valueBucket1);
1401 valueBucket2->destroy(valueBucket2);
1402 predicates->destroy(predicates);
1403 }
1404
LocalDataChangeObserverCallback7(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1405 void LocalDataChangeObserverCallback7(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1406 {
1407 // count is 0
1408 EXPECT_EQ(0, count);
1409 }
1410
LocalDataChangeObserverCallback8(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)1411 void LocalDataChangeObserverCallback8(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
1412 {
1413 // count is 0
1414 EXPECT_EQ(0, count);
1415 }
1416
1417 /**
1418 * @tc.name: RDB_Native_store_test_031
1419 * @tc.desc: normal testCase for OH_Rdb_Subscribe.
1420 * 1.register two observers for local database
1421 * 2.unRegister one of observers
1422 * @tc.type: FUNC
1423 */
1424 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_031, TestSize.Level1)
1425 {
1426 EXPECT_NE(storeTestRdbStore_, nullptr);
1427
1428 Rdb_DetailsObserver callback1 = LocalDataChangeObserverCallback7;
1429 Rdb_DataObserver observer1 = { nullptr, { callback1 } };
1430
1431 Rdb_DetailsObserver callback2 = LocalDataChangeObserverCallback8;
1432 Rdb_DataObserver observer2 = { nullptr, { callback2 } };
1433
1434 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1435 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
1436 EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
1437 EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, nullptr), RDB_OK);
1438
1439 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1440 valueBucket->putInt64(valueBucket, "id", 2);
1441 valueBucket->putText(valueBucket, "data1", "zhangSan");
1442 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
1443 // rowId is 2
1444 EXPECT_EQ(2, errCode);
1445
1446 valueBucket->destroy(valueBucket);
1447 }
1448
1449 /**
1450 * @tc.name: RDB_Native_store_test_032
1451 * @tc.desc: abNormal testCase for OH_Rdb_Subscribe.
1452 * 1.store is nullptr
1453 * 2.register observer for local database
1454 * @tc.type: FUNC
1455 */
1456 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_032, TestSize.Level1)
1457 {
1458 EXPECT_NE(storeTestRdbStore_, nullptr);
1459
1460 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback7;
1461 Rdb_DataObserver observer = { nullptr, { callback } };
1462 EXPECT_EQ(OH_Rdb_Subscribe(nullptr, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_E_INVALID_ARGS);
1463 }
1464
1465 /**
1466 * @tc.name: RDB_Native_store_test_033
1467 * @tc.desc: abNormal testCase for OH_Rdb_Subscribe.
1468 * 1.subscribe type is invalid
1469 * 2.observer is invalid
1470 * 2.register observer for local database
1471 * @tc.type: FUNC
1472 */
1473 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_033, TestSize.Level1)
1474 {
1475 EXPECT_NE(storeTestRdbStore_, nullptr);
1476
1477 Rdb_DetailsObserver callback = LocalDataChangeObserverCallback7;
1478 Rdb_DataObserver observer1 = { nullptr, { callback } };
1479 int errCode = OH_Rdb_Subscribe(nullptr, static_cast<Rdb_SubscribeType>(RDB_SUBSCRIBE_TYPE_CLOUD - 1), &observer1);
1480 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1481 errCode =
1482 OH_Rdb_Subscribe(nullptr, static_cast<Rdb_SubscribeType>(RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS + 1), &observer1);
1483 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1484
1485 Rdb_DataObserver observer2 = { nullptr, { nullptr } };
1486 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2);
1487 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1488 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, nullptr);
1489 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1490
1491 errCode = OH_Rdb_Unsubscribe(nullptr, static_cast<Rdb_SubscribeType>(RDB_SUBSCRIBE_TYPE_CLOUD - 1), &observer1);
1492 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1493 errCode =
1494 OH_Rdb_Unsubscribe(nullptr, static_cast<Rdb_SubscribeType>(RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS + 1), &observer1);
1495 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1496 }
1497
1498 /**
1499 * @tc.name: RDB_Native_store_test_034
1500 * @tc.desc: abNormal testCase for OH_Rdb_Subscribe.
1501 * 1.prams is valid or invalid
1502 * @tc.type: FUNC
1503 */
1504 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_034, TestSize.Level1)
1505 {
1506 bool isSupported = true;
1507 int errCode = OH_Rdb_IsTokenizerSupported(RDB_NONE_TOKENIZER, &isSupported);
1508 EXPECT_EQ(RDB_OK, errCode);
1509 errCode = OH_Rdb_IsTokenizerSupported(RDB_ICU_TOKENIZER, &isSupported);
1510 EXPECT_EQ(RDB_OK, errCode);
1511 errCode = OH_Rdb_IsTokenizerSupported(RDB_CUSTOM_TOKENIZER, &isSupported);
1512 EXPECT_EQ(RDB_OK, errCode);
1513 errCode = OH_Rdb_IsTokenizerSupported(static_cast<Rdb_Tokenizer>(RDB_NONE_TOKENIZER - 1), &isSupported);
1514 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1515 errCode = OH_Rdb_IsTokenizerSupported(static_cast<Rdb_Tokenizer>(RDB_CUSTOM_TOKENIZER + 1), &isSupported);
1516 EXPECT_EQ(RDB_E_INVALID_ARGS, errCode);
1517 }
1518
1519 /**
1520 * @tc.name: RDB_Native_store_test_035
1521 * @tc.desc: conflict testCase for OH_Rdb_BatchInsert.
1522 * @tc.type: FUNC
1523 */
1524 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_035, TestSize.Level1)
1525 {
1526 ASSERT_NE(storeTestRdbStore_, nullptr);
1527
1528 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1529 valueBucket->putInt64(valueBucket, "id", 12);
1530 valueBucket->putText(valueBucket, "data1", "zhangSan");
1531 int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
1532 EXPECT_EQ(12, errCode);
1533
1534 OH_Data_VBuckets *rows = OH_VBuckets_Create();
1535 ASSERT_NE(rows, nullptr);
1536 OH_VBucket *vbs[5];
1537 for (auto i = 0; i < 5; i++) {
1538 OH_VBucket *row = OH_Rdb_CreateValuesBucket();
1539 ASSERT_NE(row, nullptr);
1540 row->putInt64(row, "id", 10 + i);
1541 row->putText(row, "data1", "test_name");
1542 vbs[i] = row;
1543 EXPECT_EQ(OH_VBuckets_PutRow(rows, row), RDB_OK);
1544 }
1545
1546 int64_t changes = -1;
1547 int ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_NONE, &changes);
1548 ASSERT_EQ(ret, RDB_E_SQLITE_CONSTRAINT);
1549 ASSERT_EQ(changes, 0);
1550
1551 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_ROLLBACK, &changes);
1552 ASSERT_EQ(ret, RDB_E_SQLITE_CONSTRAINT);
1553 ASSERT_EQ(changes, 0);
1554
1555 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_ABORT, &changes);
1556 ASSERT_EQ(ret, RDB_E_SQLITE_CONSTRAINT);
1557 ASSERT_EQ(changes, 0);
1558
1559 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_FAIL, &changes);
1560 ASSERT_EQ(ret, RDB_E_SQLITE_CONSTRAINT);
1561 ASSERT_EQ(changes, 2);
1562
1563 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_IGNORE, &changes);
1564 ASSERT_EQ(ret, RDB_OK);
1565 ASSERT_EQ(changes, 2);
1566
1567 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_REPLACE, &changes);
1568 ASSERT_EQ(ret, RDB_OK);
1569 ASSERT_EQ(changes, 5);
1570
1571 for (OH_VBucket *vb : vbs) {
1572 vb->destroy(vb);
1573 }
1574 OH_VBuckets_Destroy(rows);
1575
1576 char querySql[] = "SELECT * FROM store_test";
1577 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
1578
1579 int rowCount = 0;
1580 cursor->getRowCount(cursor, &rowCount);
1581 EXPECT_EQ(rowCount, 6);
1582 cursor->destroy(cursor);
1583 }
1584
1585 /**
1586 * @tc.name: RDB_Native_store_test_036
1587 * @tc.desc: normal testCase for OH_Rdb_BatchInsert.
1588 * @tc.type: FUNC
1589 */
1590 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_036, TestSize.Level1)
1591 {
1592 ASSERT_NE(storeTestRdbStore_, nullptr);
1593
1594 OH_Data_VBuckets *rows = OH_VBuckets_Create();
1595 ASSERT_NE(rows, nullptr);
1596 OH_VBucket *vbs[2];
1597 for (auto i = 0; i < 2; i++) {
1598 OH_VBucket *row = OH_Rdb_CreateValuesBucket();
1599 ASSERT_NE(row, nullptr);
1600 row->putText(row, "data1", "test_name4");
1601 row->putInt64(row, "data2", 14800);
1602 row->putReal(row, "data3", 300.1);
1603 row->putText(row, "data5", "ABCDEFGHI");
1604 EXPECT_EQ(OH_VBuckets_PutRow(rows, row), RDB_OK);
1605 vbs[i] = row;
1606 }
1607
1608 int64_t changes = -1;
1609 int ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_NONE, &changes);
1610 ASSERT_EQ(ret, RDB_OK);
1611 ASSERT_EQ(changes, 2);
1612
1613 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_ROLLBACK, &changes);
1614 ASSERT_EQ(ret, RDB_OK);
1615 ASSERT_EQ(changes, 2);
1616
1617 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_ABORT, &changes);
1618 ASSERT_EQ(ret, RDB_OK);
1619 ASSERT_EQ(changes, 2);
1620
1621 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_FAIL, &changes);
1622 ASSERT_EQ(ret, RDB_OK);
1623 ASSERT_EQ(changes, 2);
1624
1625 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_IGNORE, &changes);
1626 ASSERT_EQ(ret, RDB_OK);
1627 ASSERT_EQ(changes, 2);
1628
1629 ret = OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_REPLACE, &changes);
1630 ASSERT_EQ(ret, RDB_OK);
1631 ASSERT_EQ(changes, 2);
1632 for (OH_VBucket *vb : vbs) {
1633 vb->destroy(vb);
1634 }
1635 OH_VBuckets_Destroy(rows);
1636
1637 char querySql[] = "SELECT * FROM store_test";
1638 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
1639
1640 int rowCount = 0;
1641 cursor->getRowCount(cursor, &rowCount);
1642 EXPECT_EQ(rowCount, 13);
1643 cursor->destroy(cursor);
1644 }
1645
1646 /**
1647 * @tc.name: RDB_Native_store_test_037
1648 * @tc.desc: normal testCase for memDb.
1649 * @tc.type: FUNC
1650 */
1651 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_037, TestSize.Level1)
1652 {
1653 OH_Rdb_ConfigV2 *config = OH_Rdb_CreateConfig();
1654 ASSERT_NE(config, nullptr);
1655 OH_Rdb_SetStoreName(config, "memDb");
1656 OH_Rdb_SetBundleName(config, "com.ohos.example.distributedndk");
1657 OH_Rdb_SetPersistent(config, false);
1658 OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL1);
1659 OH_Rdb_SetSecurityLevel(config, S1);
1660
1661 int errCode = 0;
1662 OH_Rdb_Store *store = OH_Rdb_CreateOrOpen(config, &errCode);
1663 ASSERT_NE(store, nullptr);
1664 ASSERT_EQ(errCode, OH_Rdb_ErrCode::RDB_OK);
1665
1666 char createTableSql[] = "CREATE TABLE mem_test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
1667 "data3 FLOAT, data4 BLOB, data5 TEXT);";
1668 errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
1669 EXPECT_EQ(errCode, 0);
1670
1671 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1672 valueBucket->putInt64(valueBucket, "id", 1);
1673 valueBucket->putText(valueBucket, "data1", "zhangSan");
1674 valueBucket->putInt64(valueBucket, "data2", 12800);
1675 valueBucket->putReal(valueBucket, "data3", 100.1);
1676 uint8_t arr[] = { 1, 2, 3, 4, 5 };
1677 int len = sizeof(arr) / sizeof(arr[0]);
1678 valueBucket->putBlob(valueBucket, "data4", arr, len);
1679 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1680 errCode = OH_Rdb_Insert(storeTestRdbStore_, "mem_test", valueBucket);
1681 EXPECT_EQ(errCode, 1);
1682
1683 char querySql[] = "SELECT * FROM mem_test";
1684 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
1685
1686 int rowCount = 0;
1687 cursor->getRowCount(cursor, &rowCount);
1688 EXPECT_EQ(rowCount, 1);
1689 cursor->destroy(cursor);
1690 valueBucket->destroy(valueBucket);
1691 }
1692
1693 /**
1694 * @tc.name: RDB_Native_store_test_038
1695 * @tc.desc: invalid args test.
1696 * @tc.type: FUNC
1697 */
1698 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_038, TestSize.Level1)
1699 {
1700 constexpr int TABLE_COUNT = 1;
1701 const char *table[TABLE_COUNT];
1702 table[0] = "store_test";
1703 auto errorCode = OH_Rdb_CloudSync(storeTestRdbStore_, RDB_SYNC_MODE_NATIVE_FIRST, nullptr, 1, &observer);
1704 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
1705
1706 errorCode = OH_Rdb_CloudSync(
1707 storeTestRdbStore_, static_cast<Rdb_SyncMode>(RDB_SYNC_MODE_TIME_FIRST - 1), table, TABLE_COUNT, &observer);
1708 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
1709
1710 errorCode = OH_Rdb_CloudSync(
1711 storeTestRdbStore_, static_cast<Rdb_SyncMode>(RDB_SYNC_MODE_CLOUD_FIRST + 1), table, TABLE_COUNT, &observer);
1712 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
1713
1714 OH_Predicates *predicates = OH_Rdb_CreatePredicates("lock_test");
1715 EXPECT_EQ(OH_Rdb_LockRow(nullptr, predicates), RDB_E_INVALID_ARGS);
1716 EXPECT_EQ(OH_Rdb_LockRow(storeTestRdbStore_, nullptr), RDB_E_INVALID_ARGS);
1717 EXPECT_EQ(OH_Rdb_UnlockRow(nullptr, predicates), RDB_E_INVALID_ARGS);
1718 EXPECT_EQ(OH_Rdb_UnlockRow(storeTestRdbStore_, nullptr), RDB_E_INVALID_ARGS);
1719 EXPECT_EQ(OH_Rdb_QueryLockedRow(nullptr, predicates, nullptr, 0), nullptr);
1720 EXPECT_EQ(OH_Rdb_QueryLockedRow(storeTestRdbStore_, nullptr, nullptr, 0), nullptr);
1721 predicates->destroy(predicates);
1722
1723 errorCode = OH_Rdb_IsTokenizerSupported(RDB_CUSTOM_TOKENIZER, nullptr);
1724 EXPECT_EQ(errorCode, RDB_E_INVALID_ARGS);
1725
1726 OH_Data_VBuckets *rows = OH_VBuckets_Create();
1727 int64_t changes = -1;
1728 EXPECT_EQ(OH_Rdb_BatchInsert(nullptr, nullptr, nullptr, RDB_CONFLICT_NONE, nullptr), RDB_E_INVALID_ARGS);
1729 EXPECT_EQ(OH_Rdb_BatchInsert(storeTestRdbStore_, nullptr, nullptr, RDB_CONFLICT_NONE, nullptr), RDB_E_INVALID_ARGS);
1730 EXPECT_EQ(
1731 OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", nullptr, RDB_CONFLICT_NONE, nullptr), RDB_E_INVALID_ARGS);
1732 EXPECT_EQ(
1733 OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, RDB_CONFLICT_NONE, nullptr), RDB_E_INVALID_ARGS);
1734 auto invalidResolution = static_cast<Rdb_ConflictResolution>(RDB_CONFLICT_NONE - 1);
1735 EXPECT_EQ(
1736 OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, invalidResolution, &changes), RDB_E_INVALID_ARGS);
1737 invalidResolution = static_cast<Rdb_ConflictResolution>(RDB_CONFLICT_REPLACE + 1);
1738 EXPECT_EQ(
1739 OH_Rdb_BatchInsert(storeTestRdbStore_, "store_test", rows, invalidResolution, &changes), RDB_E_INVALID_ARGS);
1740 OH_VBuckets_Destroy(rows);
1741
1742 EXPECT_EQ(OH_Value_PutText(nullptr, "test"), RDB_E_INVALID_ARGS);
1743
1744 Rdb_DistributedConfig config{ .version = 0, .isAutoSync = true };
1745 EXPECT_EQ(
1746 OH_Rdb_SetDistributedTables(storeTestRdbStore_, table, 0, RDB_DISTRIBUTED_CLOUD, &config), RDB_E_INVALID_ARGS);
1747 }
1748
1749 /**
1750 * @tc.name: RDB_Native_store_test_039
1751 * @tc.desc: normal testCase for OH_Rdb_InsertWithConflictResolution.
1752 * @tc.type: FUNC
1753 */
1754 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_039, TestSize.Level1)
1755 {
1756 int errCode = 0;
1757 OH_Rdb_Store *store = storeTestRdbStore_;
1758 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1759 valueBucket->putInt64(valueBucket, "id", 2);
1760 valueBucket->putText(valueBucket, "data1", "liSi");
1761 valueBucket->putInt64(valueBucket, "data2", 13800);
1762 valueBucket->putReal(valueBucket, "data3", 200.1);
1763 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
1764 int64_t rowId = 0;
1765 errCode = OH_Rdb_InsertWithConflictResolution(nullptr, "store_test", valueBucket, RDB_CONFLICT_ROLLBACK, &rowId);
1766 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1767
1768 errCode = OH_Rdb_InsertWithConflictResolution(store, nullptr, valueBucket, RDB_CONFLICT_ROLLBACK, &rowId);
1769 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1770
1771 errCode = OH_Rdb_InsertWithConflictResolution(store, "store_test", nullptr, RDB_CONFLICT_ROLLBACK, &rowId);
1772 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1773
1774 errCode = OH_Rdb_InsertWithConflictResolution(store, "store_test", valueBucket,
1775 static_cast<Rdb_ConflictResolution>(0), &rowId);
1776 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1777
1778 errCode = OH_Rdb_InsertWithConflictResolution(store, "store_test", valueBucket,
1779 static_cast<Rdb_ConflictResolution>(RDB_CONFLICT_REPLACE + 1), &rowId);
1780 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1781
1782 errCode = OH_Rdb_InsertWithConflictResolution(store, "store_test", valueBucket, RDB_CONFLICT_ROLLBACK, nullptr);
1783 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1784
1785 errCode = OH_Rdb_InsertWithConflictResolution(store, "store_test", valueBucket, RDB_CONFLICT_ROLLBACK, &rowId);
1786 EXPECT_EQ(errCode, RDB_OK);
1787 EXPECT_EQ(rowId, 2);
1788
1789 valueBucket->destroy(valueBucket);
1790 }
1791
1792 /**
1793 * @tc.name: RDB_Native_store_test_040
1794 * @tc.desc: normal testCase for OH_Rdb_UpdateWithConflictResolution.
1795 * @tc.type: FUNC
1796 */
1797 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_040, TestSize.Level1)
1798 {
1799 int errCode = 0;
1800 OH_Rdb_Store *store = storeTestRdbStore_;
1801 OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
1802 EXPECT_NE(predicates, NULL);
1803
1804 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1805 EXPECT_NE(valueObject, NULL);
1806 const char *data1Value = "zhangSan";
1807 valueObject->putText(valueObject, data1Value);
1808
1809 predicates->equalTo(predicates, "data1", valueObject);
1810
1811 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
1812 EXPECT_NE(valueBucket, NULL);
1813 valueBucket->putText(valueBucket, "data1", "liSi");
1814 valueBucket->putInt64(valueBucket, "data2", 13800);
1815 valueBucket->putReal(valueBucket, "data3", 200.1);
1816 valueBucket->putNull(valueBucket, "data5");
1817
1818 int64_t chgs = 0;
1819 errCode = OH_Rdb_UpdateWithConflictResolution(nullptr, valueBucket, predicates, RDB_CONFLICT_ROLLBACK, &chgs);
1820 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1821 errCode = OH_Rdb_UpdateWithConflictResolution(store, nullptr, predicates, RDB_CONFLICT_ROLLBACK, &chgs);
1822 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1823 errCode = OH_Rdb_UpdateWithConflictResolution(store, valueBucket, nullptr, RDB_CONFLICT_ROLLBACK, nullptr);
1824 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1825 errCode = OH_Rdb_UpdateWithConflictResolution(store, valueBucket, predicates, RDB_CONFLICT_ROLLBACK, &chgs);
1826 EXPECT_EQ(errCode, RDB_OK);
1827 EXPECT_EQ(chgs, 1);
1828
1829 predicates->clear(predicates);
1830 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
1831 EXPECT_NE(cursor, NULL);
1832
1833 int rowCount = 0;
1834 cursor->getRowCount(cursor, &rowCount);
1835 EXPECT_EQ(rowCount, 1);
1836
1837 errCode = cursor->goToNextRow(cursor);
1838 EXPECT_EQ(errCode, 0);
1839
1840 size_t size = 0;
1841 cursor->getSize(cursor, 1, &size);
1842 EXPECT_EQ(size, 5);
1843 char data1Value1[size];
1844 cursor->getText(cursor, 1, data1Value1, size);
1845 EXPECT_STREQ(data1Value1, "liSi");
1846
1847 valueObject->destroy(valueObject);
1848 valueBucket->destroy(valueBucket);
1849 predicates->destroy(predicates);
1850 cursor->destroy(cursor);
1851 }
1852
1853 static OH_Rdb_ConfigV2 *g_attachConfig = nullptr;
CreateAttachDatabase()1854 static void CreateAttachDatabase()
1855 {
1856 g_attachConfig = OH_Rdb_CreateConfig();
1857 ASSERT_NE(g_attachConfig, nullptr);
1858 OH_Rdb_SetDatabaseDir(g_attachConfig, RDB_TEST_PATH);
1859 OH_Rdb_SetStoreName(g_attachConfig, "rdb_attach_store_test.db");
1860 OH_Rdb_SetBundleName(g_attachConfig, "com.ohos.example.distributedndk");
1861 OH_Rdb_SetEncrypted(g_attachConfig, false);
1862 OH_Rdb_SetSecurityLevel(g_attachConfig, OH_Rdb_SecurityLevel::S1);
1863 OH_Rdb_SetArea(g_attachConfig, RDB_SECURITY_AREA_EL1);
1864
1865 int errCode = 0;
1866 auto tmpStore = OH_Rdb_CreateOrOpen(g_attachConfig, &errCode);
1867 EXPECT_NE(tmpStore, NULL);
1868 OH_Rdb_CloseStore(tmpStore);
1869 }
1870
DeleteAttachDatabase()1871 static void DeleteAttachDatabase()
1872 {
1873 EXPECT_EQ(OH_Rdb_DeleteStoreV2(g_attachConfig), 0);
1874 OH_Rdb_DestroyConfig(g_attachConfig);
1875 g_attachConfig = nullptr;
1876 }
1877
1878 /**
1879 * @tc.name: RDB_Native_store_test_041
1880 * @tc.desc: normal testCase for OH_Rdb_Attach、OH_Rdb_Detach.
1881 * @tc.type: FUNC
1882 */
1883 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_041, TestSize.Level1)
1884 {
1885 CreateAttachDatabase();
1886
1887 size_t attachedNumber = 0;
1888 auto ret = OH_Rdb_Attach(nullptr, g_attachConfig, "rdb_attach_test", 3, &attachedNumber);
1889 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1890 ret = OH_Rdb_Attach(storeTestRdbStore_, nullptr, "rdb_attach_test", 3, &attachedNumber);
1891 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1892 ret = OH_Rdb_Attach(storeTestRdbStore_, g_attachConfig, nullptr, 3, &attachedNumber);
1893 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1894 ret = OH_Rdb_Attach(storeTestRdbStore_, g_attachConfig, "rdb_attach_test", 0, &attachedNumber);
1895 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1896 ret = OH_Rdb_Attach(storeTestRdbStore_, g_attachConfig, "rdb_attach_test", 3, nullptr);
1897 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1898 ret = OH_Rdb_Attach(storeTestRdbStore_, g_attachConfig, "rdb_attach_test", 3, &attachedNumber);
1899 EXPECT_EQ(ret, RDB_OK);
1900 EXPECT_EQ(attachedNumber, 1);
1901
1902 ret = OH_Rdb_Detach(nullptr, "rdb_attach_test", 3, &attachedNumber);
1903 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1904 ret = OH_Rdb_Detach(storeTestRdbStore_, nullptr, 3, &attachedNumber);
1905 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1906 ret = OH_Rdb_Detach(storeTestRdbStore_, "rdb_attach_test", 0, &attachedNumber);
1907 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1908 ret = OH_Rdb_Detach(storeTestRdbStore_, "rdb_attach_test", 3, nullptr);
1909 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1910 ret = OH_Rdb_Detach(storeTestRdbStore_, "rdb_attach_test", 3, &attachedNumber);
1911 EXPECT_EQ(ret, RDB_OK);
1912 EXPECT_EQ(attachedNumber, 0);
1913
1914 DeleteAttachDatabase();
1915 }
1916
1917 /**
1918 * @tc.name: RDB_Native_store_test_042
1919 * @tc.desc: normal testCase for OH_Rdb_SetLocale.
1920 * @tc.type: FUNC
1921 */
1922 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_042, TestSize.Level1)
1923 {
1924 int errCode = 0;
1925 OH_Rdb_Store *store = storeTestRdbStore_;
1926 errCode = OH_Rdb_SetLocale(nullptr, "zh");
1927 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1928 errCode = OH_Rdb_SetLocale(store, nullptr);
1929 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
1930 errCode = OH_Rdb_SetLocale(store, "zh");
1931 EXPECT_EQ(errCode, RDB_OK);
1932 }
1933
1934 /**
1935 * @tc.name: RDB_Native_store_test_044
1936 * @tc.desc: GetAsset parameter invalid test
1937 * @tc.type: FUNC
1938 */
1939 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_044, TestSize.Level0)
1940 {
1941 OH_Data_Value *dataValue = OH_Value_Create();
1942 auto ret = OH_Value_GetAsset(dataValue, nullptr);
1943 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1944 }
1945 /**
1946 * @tc.name: RDB_SubscribeAutoSyncProgress_test_001
1947 * @tc.desc: Abnormal testCase for SubscribeAutoSyncProgress.
1948 * @tc.type: FUNC
1949 */
1950 HWTEST_F(RdbNativeStoreTest, RDB_SubscribeAutoSyncProgress_test_001, TestSize.Level1)
1951 {
1952 RelationalStore ndkStore(nullptr);
1953 auto ret = ndkStore.SubscribeAutoSyncProgress(&observer);
1954 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1955 }
1956
1957 /**
1958 * @tc.name: RDB_UnsubscribeAutoSyncProgress_test_001
1959 * @tc.desc: Abnormal testCase for UnsubscribeAutoSyncProgress.
1960 * @tc.type: FUNC
1961 */
1962 HWTEST_F(RdbNativeStoreTest, RDB_UnsubscribeAutoSyncProgress_test_001, TestSize.Level1)
1963 {
1964 RelationalStore ndkStore(nullptr);
1965 auto ret = ndkStore.UnsubscribeAutoSyncProgress(&observer);
1966 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
1967 }
1968