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 <iostream>
16 #include <stdio.h>
17 #include <unistd.h>
18 #include <string>
19 #include <string.h>
20 #include <cstdio>
21 #include <cstdlib>
22 #include <fcntl.h>
23 #include <securec.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26
27 #include "napi/native_api.h"
28 #include "common/common.h"
29 #include "relational_store.h"
30 #include "relational_store_error_code.h"
31 #include "oh_cursor.h"
32 #include "oh_predicates.h"
33 #include "oh_value_object.h"
34 #include "oh_values_bucket.h"
35
36 char *RDB_TEST_PATH = NULL;
37
38 char RDB_STORE_NAME[] = "rdb_store_test.db";
39 char BUNDLE_NAME[] = "com.acts.rdb.napitest";
40 char MODULE_NAME[] = "com.acts.rdb.napitest";
41
42 OH_Rdb_Store *storeBackupTestRdbStore_ = NULL;
43 static OH_Rdb_Config config_;
InitRdbConfig()44 static void InitRdbConfig()
45 {
46 config_.dataBaseDir = RDB_TEST_PATH;
47 config_.storeName = RDB_STORE_NAME;
48 config_.bundleName = BUNDLE_NAME;
49 config_.moduleName = MODULE_NAME;
50 config_.securityLevel = OH_Rdb_SecurityLevel::S1;
51 config_.isEncrypt = false;
52 config_.selfSize = sizeof(OH_Rdb_Config);
53 }
54
RdbFilePath(napi_env env,napi_callback_info info)55 static napi_value RdbFilePath(napi_env env, napi_callback_info info) {
56 int errCode = 0;
57 size_t argc = 1;
58 napi_value args[1] = {nullptr};
59 napi_get_cb_info(env, info, &argc, args , nullptr, nullptr);
60
61 size_t bufferSize = 0;
62 napi_get_value_string_latin1(env, args[0], nullptr, 0, &bufferSize);
63
64 char *buffer = (char*)malloc((bufferSize) + 1);
65 napi_get_value_string_utf8(env, args[0], buffer, bufferSize+1, &bufferSize);
66
67 RDB_TEST_PATH = (char*)malloc((bufferSize) + 1);
68 sprintf(RDB_TEST_PATH, "%s/", buffer);
69
70 napi_value returnCode;
71 napi_create_double(env, errCode, &returnCode);
72 return returnCode;
73 }
74
RdbstoreSetUpTestCase(napi_env env,napi_callback_info info)75 static napi_value RdbstoreSetUpTestCase(napi_env env, napi_callback_info info) {
76
77 InitRdbConfig();
78 mkdir(config_.dataBaseDir, 0770);
79
80 int errCode = 0;
81 storeBackupTestRdbStore_ = OH_Rdb_GetOrOpen(&config_, &errCode);
82 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_GetOrOpen is fail.");
83 NAPI_ASSERT(env, storeBackupTestRdbStore_ != NULL, "OH_Rdb_GetOrOpen config is fail.");
84
85 char createTableSql[] = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
86 "data3 FLOAT, data4 BLOB, data5 TEXT);";
87 errCode = OH_Rdb_Execute(storeBackupTestRdbStore_, createTableSql);
88 NAPI_ASSERT(env, errCode == 0, "createTable is fail.");
89
90 napi_value returnCode;
91 napi_create_double(env, errCode, &returnCode);
92 return returnCode;
93 }
94
RdbstoreTearDownTestCase(napi_env env,napi_callback_info info)95 static napi_value RdbstoreTearDownTestCase(napi_env env, napi_callback_info info) {
96 int errCode = 0;
97 char dropTableSql[] = "DROP TABLE IF EXISTS test";
98 OH_Rdb_Execute(storeBackupTestRdbStore_, dropTableSql);
99 OH_Rdb_CloseStore(storeBackupTestRdbStore_);
100 errCode = OH_Rdb_DeleteStore(&config_);
101
102 napi_value returnCode;
103 napi_create_double(env, errCode, &returnCode);
104 return returnCode;
105 }
106
SUB_DDM_RDB_BackupRestoreTest_0100(napi_env env,napi_callback_info info)107 static napi_value SUB_DDM_RDB_BackupRestoreTest_0100(napi_env env, napi_callback_info info) {
108
109 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
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
118 int errCode = OH_Rdb_Insert(storeBackupTestRdbStore_, "test", valueBucket);
119 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
120
121 char querySql[] = "SELECT * FROM test";
122 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
123
124 int rowCount = 0;
125 cursor->getRowCount(cursor, &rowCount);
126 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
127 cursor->destroy(cursor);
128
129 char dbpath[] = "";
130 char backupPath[100];
131 sprintf(backupPath, "%s%s", RDB_TEST_PATH, dbpath);
132 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath);
133 NAPI_ASSERT(env, errCode == 14800011, "OH_Rdb_Backup is success.");
134
135 errCode = valueBucket->destroy(valueBucket);
136
137 napi_value returnCode;
138 napi_create_double(env, errCode, &returnCode);
139 return returnCode;
140 }
141
SUB_DDM_RDB_BackupRestoreTest_0300(napi_env env,napi_callback_info info)142 static napi_value SUB_DDM_RDB_BackupRestoreTest_0300(napi_env env, napi_callback_info info) {
143 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
144 valueBucket->putInt64(valueBucket, "id", 1);
145 valueBucket->putText(valueBucket, "data1", "zhangSan");
146 valueBucket->putInt64(valueBucket, "data2", 12800);
147 valueBucket->putReal(valueBucket, "data3", 100.1);
148 uint8_t arr[] = {1, 2, 3, 4, 5};
149 int len = sizeof(arr) / sizeof(arr[0]);
150 valueBucket->putBlob(valueBucket, "data4", arr, len);
151 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
152 int errCode = OH_Rdb_Insert(storeBackupTestRdbStore_, "test", valueBucket);
153 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
154
155 char querySql[] = "SELECT * FROM test";
156 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
157
158 int rowCount = 0;
159 cursor->getRowCount(cursor, &rowCount);
160 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
161 cursor->destroy(cursor);
162
163 char dbpath[] = "backup.db";
164 char backupPath[100];
165 sprintf(backupPath, "%s%s", RDB_TEST_PATH, dbpath);
166 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath);
167 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Backup1 is fail.");
168
169 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath);
170 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Backup2 is fail.");
171
172 // delete data before restore
173 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
174 errCode = OH_Rdb_Delete(storeBackupTestRdbStore_, predicates);
175 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Delete is fail.");
176
177 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, backupPath);
178 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Restore is fail.");
179
180 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
181 cursor->getRowCount(cursor, &rowCount);
182 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
183
184 errCode = cursor->goToNextRow(cursor);
185 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
186
187 size_t size = 0;
188 cursor->getSize(cursor, 1, &size);
189 char data1Value[size + 1];
190 cursor->getText(cursor, 1, data1Value, size + 1);
191 NAPI_ASSERT(env, strncmp(data1Value, "zhangSan", 8) == 0, "getText is fail.");
192
193 int64_t data2Value;
194 cursor->getInt64(cursor, 2, &data2Value);
195 NAPI_ASSERT(env, data2Value == 12800, "getInt64 is fail.");
196
197 double data3Value;
198 cursor->getReal(cursor, 3, &data3Value);
199 NAPI_ASSERT(env, data3Value == 100.1, "getReal is fail.");
200
201 cursor->getSize(cursor, 4, &size);
202 unsigned char data4Value[size];
203 cursor->getBlob(cursor, 4, data4Value, size);
204 NAPI_ASSERT(env, data4Value[0] == 1, "getBlob1 is fail.");
205 NAPI_ASSERT(env, data4Value[1] == 2, "getBlob2 is fail.");
206
207 cursor->getSize(cursor, 5, &size);
208 char data5Value[size + 1];
209 cursor->getText(cursor, 5, data5Value, size + 1);
210 NAPI_ASSERT(env, strncmp(data5Value, "ABCDEFG", 7) == 0, "getText is fail.");
211
212 valueBucket->destroy(valueBucket);
213 errCode = cursor->destroy(cursor);
214
215 napi_value returnCode;
216 napi_create_double(env, errCode, &returnCode);
217 return returnCode;
218 }
219
SUB_DDM_RDB_BackupRestoreTest_0400(napi_env env,napi_callback_info info)220 static napi_value SUB_DDM_RDB_BackupRestoreTest_0400(napi_env env, napi_callback_info info) {
221 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
222 valueBucket->putInt64(valueBucket, "id", 1);
223 valueBucket->putText(valueBucket, "data1", "zhangSan");
224 valueBucket->putInt64(valueBucket, "data2", 12800);
225 valueBucket->putReal(valueBucket, "data3", 100.1);
226 uint8_t arr[] = {1, 2, 3, 4, 5};
227 int len = sizeof(arr) / sizeof(arr[0]);
228 valueBucket->putBlob(valueBucket, "data4", arr, len);
229 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
230 int errCode = OH_Rdb_Insert(storeBackupTestRdbStore_, "test", valueBucket);
231 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
232
233 char querySql[] = "SELECT * FROM test";
234 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
235
236 int rowCount = 0;
237 cursor->getRowCount(cursor, &rowCount);
238 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
239 cursor->destroy(cursor);
240
241 char dbpath1[] = "backup1.db";
242 char backupPath1[100];
243 sprintf(backupPath1, "%s%s", RDB_TEST_PATH, dbpath1);
244 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath1);
245 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Backup1 is fail.");
246
247 char dbpath2[] = "backup2.db";
248 char backupPath2[100];
249 sprintf(backupPath2, "%s%s", RDB_TEST_PATH, dbpath2);
250 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath2);
251 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Backup2 is fail.");
252
253 // delete data before restore
254 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
255 errCode = OH_Rdb_Delete(storeBackupTestRdbStore_, predicates);
256 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Delete is fail.");
257
258 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, backupPath1);
259 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Restore1 is fail.");
260
261 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, backupPath2);
262 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Restore2 is fail.");
263
264 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
265 cursor->getRowCount(cursor, &rowCount);
266 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
267
268 errCode = cursor->goToNextRow(cursor);
269 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
270
271 valueBucket->destroy(valueBucket);
272 errCode = cursor->destroy(cursor);
273
274 napi_value returnCode;
275 napi_create_double(env, errCode, &returnCode);
276 return returnCode;
277 }
278
279
SUB_DDM_RDB_BackupRestoreTest_0500(napi_env env,napi_callback_info info)280 static napi_value SUB_DDM_RDB_BackupRestoreTest_0500(napi_env env, napi_callback_info info) {
281 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
282 valueBucket->putInt64(valueBucket, "id", 1);
283 valueBucket->putText(valueBucket, "data1", "zhangSan");
284 valueBucket->putInt64(valueBucket, "data2", 12800);
285 valueBucket->putReal(valueBucket, "data3", 100.1);
286 uint8_t arr[] = {1, 2, 3, 4, 5};
287 int len = sizeof(arr) / sizeof(arr[0]);
288 valueBucket->putBlob(valueBucket, "data4", arr, len);
289 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
290 int errCode = OH_Rdb_Insert(storeBackupTestRdbStore_, "test", valueBucket);
291 NAPI_ASSERT(env, errCode == 1, "Insert data is fail.");
292
293 char querySql[] = "SELECT * FROM test";
294 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
295
296 int rowCount = 0;
297 cursor->getRowCount(cursor, &rowCount);
298 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
299 cursor->destroy(cursor);
300
301 char dbpath[] = "backup.db";
302 char backupPath[100];
303 sprintf(backupPath, "%s%s", RDB_TEST_PATH, dbpath);
304
305 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath);
306 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Backup is fail.");
307
308 // delete data before restore
309 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
310 errCode = OH_Rdb_Delete(storeBackupTestRdbStore_, predicates);
311 NAPI_ASSERT(env, errCode == 1, "DeleteData is fail.");
312
313 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, backupPath);
314 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Restore is fail.");
315
316 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
317 cursor->getRowCount(cursor, &rowCount);
318 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
319
320 errCode = cursor->goToNextRow(cursor);
321 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
322
323 size_t size = 0;
324 cursor->getSize(cursor, 1, &size);
325 char data1Value[size + 1];
326 cursor->getText(cursor, 1, data1Value, size + 1);
327 NAPI_ASSERT(env, strncmp(data1Value, "zhangSan", 8) == 0, "getText is fail.");
328
329 int64_t data2Value;
330 cursor->getInt64(cursor, 2, &data2Value);
331 NAPI_ASSERT(env, data2Value == 12800, "getInt64 is fail.");
332
333 double data3Value;
334 cursor->getReal(cursor, 3, &data3Value);
335 NAPI_ASSERT(env, data3Value == 100.1, "getReal is fail.");
336
337 cursor->getSize(cursor, 4, &size);
338 unsigned char data4Value[size];
339 cursor->getBlob(cursor, 4, data4Value, size);
340 NAPI_ASSERT(env, data4Value[0] == 1, "getBlob1 is fail.");
341 NAPI_ASSERT(env, data4Value[1] == 2, "getBlob2 is fail.");
342
343 cursor->getSize(cursor, 5, &size);
344 char data5Value[size + 1];
345 cursor->getText(cursor, 5, data5Value, size + 1);
346 NAPI_ASSERT(env, strncmp(data5Value, "ABCDEFG", 7) == 0, "getText is fail.");
347
348 valueBucket->destroy(valueBucket);
349 errCode = cursor->destroy(cursor);
350
351 napi_value returnCode;
352 napi_create_double(env, errCode, &returnCode);
353 return returnCode;
354 }
355
356
SUB_DDM_RDB_BackupRestoreTest_0600(napi_env env,napi_callback_info info)357 static napi_value SUB_DDM_RDB_BackupRestoreTest_0600(napi_env env, napi_callback_info info) {
358 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
359 valueBucket->putInt64(valueBucket, "id", 1);
360 valueBucket->putText(valueBucket, "data1", "zhangSan");
361 valueBucket->putInt64(valueBucket, "data2", 12800);
362 valueBucket->putReal(valueBucket, "data3", 100.1);
363 uint8_t arr[] = {1, 2, 3, 4, 5};
364 int len = sizeof(arr) / sizeof(arr[0]);
365 valueBucket->putBlob(valueBucket, "data4", arr, len);
366 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
367 int errCode = OH_Rdb_Insert(storeBackupTestRdbStore_, "test", valueBucket);
368 NAPI_ASSERT(env, errCode == 1, "Insert data is fail.");
369
370 char querySql[] = "SELECT * FROM test";
371 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
372
373 int rowCount = 0;
374 cursor->getRowCount(cursor, &rowCount);
375 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
376 cursor->destroy(cursor);
377
378 char dbpath[] = " ";
379 char backupPath[100];
380 sprintf(backupPath, "%s%s", RDB_TEST_PATH, dbpath);
381 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath);
382 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Backup is fail.");
383
384 // delete data before restore
385 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
386 errCode = OH_Rdb_Delete(storeBackupTestRdbStore_, predicates);
387 NAPI_ASSERT(env, errCode == 1, "DeleteData is fail.");
388
389 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, backupPath);
390 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Restore is fail.");
391
392 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
393 cursor->getRowCount(cursor, &rowCount);
394 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
395
396 errCode = cursor->goToNextRow(cursor);
397 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
398
399 size_t size = 0;
400 cursor->getSize(cursor, 1, &size);
401 char data1Value[size + 1];
402 cursor->getText(cursor, 1, data1Value, size + 1);
403 NAPI_ASSERT(env, strncmp(data1Value, "zhangSan", 8) == 0, "getText is fail.");
404
405 int64_t data2Value;
406 cursor->getInt64(cursor, 2, &data2Value);
407 NAPI_ASSERT(env, data2Value == 12800, "getInt64 is fail.");
408
409 double data3Value;
410 cursor->getReal(cursor, 3, &data3Value);
411 NAPI_ASSERT(env, data3Value == 100.1, "getReal is fail.");
412
413 cursor->getSize(cursor, 4, &size);
414 unsigned char data4Value[size];
415 cursor->getBlob(cursor, 4, data4Value, size);
416 NAPI_ASSERT(env, data4Value[0] == 1, "getBlob1 is fail.");
417 NAPI_ASSERT(env, data4Value[1] == 2, "getBlob2 is fail.");
418
419 cursor->getSize(cursor, 5, &size);
420 char data5Value[size + 1];
421 cursor->getText(cursor, 5, data5Value, size + 1);
422 NAPI_ASSERT(env, strncmp(data5Value, "ABCDEFG", 7) == 0, "getText is fail.");
423
424 valueBucket->destroy(valueBucket);
425 errCode = cursor->destroy(cursor);
426
427 napi_value returnCode;
428 napi_create_double(env, errCode, &returnCode);
429 return returnCode;
430 }
431
SUB_DDM_RDB_BackupRestoreTest_0700(napi_env env,napi_callback_info info)432 static napi_value SUB_DDM_RDB_BackupRestoreTest_0700(napi_env env, napi_callback_info info) {
433 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
434 valueBucket->putInt64(valueBucket, "id", 1);
435 valueBucket->putText(valueBucket, "data1", "zhangSan");
436 valueBucket->putInt64(valueBucket, "data2", 12800);
437 valueBucket->putReal(valueBucket, "data3", 100.1);
438 uint8_t arr[] = {1, 2, 3, 4, 5};
439 int len = sizeof(arr) / sizeof(arr[0]);
440 valueBucket->putBlob(valueBucket, "data4", arr, len);
441 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
442 int errCode = OH_Rdb_Insert(storeBackupTestRdbStore_, "test", valueBucket);
443 NAPI_ASSERT(env, errCode == 1, "Insert data is fail.");
444
445 char querySql[] = "SELECT * FROM test";
446 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
447
448 int rowCount = 0;
449 cursor->getRowCount(cursor, &rowCount);
450 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
451 cursor->destroy(cursor);
452
453 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, NULL);
454 NAPI_ASSERT(env, errCode == 14800001, "OH_Rdb_Backup is success.");
455
456 errCode = valueBucket->destroy(valueBucket);
457
458 napi_value returnCode;
459 napi_create_double(env, errCode, &returnCode);
460 return returnCode;
461 }
462
SUB_DDM_RDB_BackupRestoreTest_0800(napi_env env,napi_callback_info info)463 static napi_value SUB_DDM_RDB_BackupRestoreTest_0800(napi_env env, napi_callback_info info) {
464 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
465 valueBucket->putInt64(valueBucket, "id", 1);
466 valueBucket->putText(valueBucket, "data1", "zhangSan");
467 valueBucket->putInt64(valueBucket, "data2", 12800);
468 valueBucket->putReal(valueBucket, "data3", 100.1);
469 uint8_t arr[] = {1, 2, 3, 4, 5};
470 int len = sizeof(arr) / sizeof(arr[0]);
471 valueBucket->putBlob(valueBucket, "data4", arr, len);
472 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
473 int errCode = OH_Rdb_Insert(storeBackupTestRdbStore_, "test", valueBucket);
474 NAPI_ASSERT(env, errCode == 1, "Insert data is fail.");
475
476 char querySql[] = "SELECT * FROM test";
477 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
478
479 int rowCount = 0;
480 cursor->getRowCount(cursor, &rowCount);
481 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
482 cursor->destroy(cursor);
483
484 char dbpath[] = "backupNull.db";
485 char backupPath[100];
486 sprintf(backupPath, "%s%s", RDB_TEST_PATH, dbpath);
487 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath);
488 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Backup is fail.");
489
490 // delete data before restore
491 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
492 errCode = OH_Rdb_Delete(storeBackupTestRdbStore_, predicates);
493 NAPI_ASSERT(env, errCode == 1, "DeleteData is fail.");
494
495 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, NULL);
496 NAPI_ASSERT(env, errCode == 14800001, "OH_Rdb_Restore is success.");
497
498 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
499 cursor->getRowCount(cursor, &rowCount);
500 NAPI_ASSERT(env, rowCount == 0, "getRowCount is success.");
501
502 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, backupPath);
503 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Restore is fail.");
504
505 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
506 cursor->getRowCount(cursor, &rowCount);
507 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
508
509 errCode = cursor->goToNextRow(cursor);
510 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
511
512 size_t size = 0;
513 cursor->getSize(cursor, 1, &size);
514 char data1Value[size + 1];
515 cursor->getText(cursor, 1, data1Value, size + 1);
516 NAPI_ASSERT(env, strncmp(data1Value, "zhangSan", 8) == 0, "getText is fail.");
517
518 int64_t data2Value;
519 cursor->getInt64(cursor, 2, &data2Value);
520 NAPI_ASSERT(env, data2Value == 12800, "getInt64 is fail.");
521
522 double data3Value;
523 cursor->getReal(cursor, 3, &data3Value);
524 NAPI_ASSERT(env, data3Value == 100.1, "getReal is fail.");
525
526 cursor->getSize(cursor, 4, &size);
527 unsigned char data4Value[size];
528 cursor->getBlob(cursor, 4, data4Value, size);
529 NAPI_ASSERT(env, data4Value[0] == 1, "getBlob1 is fail.");
530 NAPI_ASSERT(env, data4Value[1] == 2, "getBlob2 is fail.");
531
532 cursor->getSize(cursor, 5, &size);
533 char data5Value[size + 1];
534 cursor->getText(cursor, 5, data5Value, size + 1);
535 NAPI_ASSERT(env, strncmp(data5Value, "ABCDEFG", 7) == 0, "getText is fail.");
536
537 valueBucket->destroy(valueBucket);
538 errCode = cursor->destroy(cursor);
539
540 napi_value returnCode;
541 napi_create_double(env, errCode, &returnCode);
542 return returnCode;
543 }
544
545
546
SUB_DDM_RDB_BackupRestoreTest_0900(napi_env env,napi_callback_info info)547 static napi_value SUB_DDM_RDB_BackupRestoreTest_0900(napi_env env, napi_callback_info info) {
548 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
549 valueBucket->putText(valueBucket, "data1", "zhangSan");
550 valueBucket->putInt64(valueBucket, "data2", 12800);
551 valueBucket->putReal(valueBucket, "data3", 100.1);
552 uint8_t arr[] = {1, 2, 3, 4, 5};
553 int len = sizeof(arr) / sizeof(arr[0]);
554 valueBucket->putBlob(valueBucket, "data4", arr, len);
555 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
556
557 int errCode = OH_Rdb_Insert(storeBackupTestRdbStore_, "test", valueBucket);
558 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
559
560 char querySql[] = "SELECT * FROM test";
561 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
562
563 int rowCount = 0;
564 cursor->getRowCount(cursor, &rowCount);
565 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
566 cursor->destroy(cursor);
567
568 char dbpath[] = "backupEmpty.db";
569 char backupPath[100];
570 sprintf(backupPath, "%s%s", RDB_TEST_PATH, dbpath);
571 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath);
572 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Backup is fail.");
573
574 // delete data before restore
575 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
576 errCode = OH_Rdb_Delete(storeBackupTestRdbStore_, predicates);
577 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Delete is fail.");
578
579 char dbpath1[] = "";
580 char reStorePath[100];
581 sprintf(reStorePath, "%s%s", RDB_TEST_PATH, dbpath1);
582
583 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, reStorePath);
584 NAPI_ASSERT(env, errCode == 14800011, "OH_Rdb_Restore is success.");
585
586 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
587 cursor->getRowCount(cursor, &rowCount);
588 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
589
590 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, backupPath);
591 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Restore is fail.");
592
593 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
594 cursor->getRowCount(cursor, &rowCount);
595 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
596
597 valueBucket->destroy(valueBucket);
598 errCode = cursor->destroy(cursor);
599
600 napi_value returnCode;
601 napi_create_double(env, errCode, &returnCode);
602 return returnCode;
603 }
604
SUB_DDM_RDB_BackupRestoreTest_0110(napi_env env,napi_callback_info info)605 static napi_value SUB_DDM_RDB_BackupRestoreTest_0110(napi_env env, napi_callback_info info) {
606 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
607 valueBucket->putText(valueBucket, "data1", "zhangSan");
608 valueBucket->putInt64(valueBucket, "data2", 12800);
609 valueBucket->putReal(valueBucket, "data3", 100.1);
610 uint8_t arr[] = {1, 2, 3, 4, 5};
611 int len = sizeof(arr) / sizeof(arr[0]);
612 valueBucket->putBlob(valueBucket, "data4", arr, len);
613 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
614
615 int errCode = OH_Rdb_Insert(storeBackupTestRdbStore_, "test", valueBucket);
616 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
617
618 char querySql[] = "SELECT * FROM test";
619 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
620
621 int rowCount = 0;
622 cursor->getRowCount(cursor, &rowCount);
623 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
624 cursor->destroy(cursor);
625
626 char dbpath[] = "backupWrong.db";
627 char backupPath[100];
628 sprintf(backupPath, "%s%s", RDB_TEST_PATH, dbpath);
629
630 errCode = OH_Rdb_Backup(storeBackupTestRdbStore_, backupPath);
631 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Backup is fail.");
632
633 // delete data before restore
634 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
635 errCode = OH_Rdb_Delete(storeBackupTestRdbStore_, predicates);
636 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Delete is fail.");
637
638 char dbpath2[] = "wrong.db";
639 char reStorePath[100];
640 sprintf(reStorePath, "%s%s", RDB_TEST_PATH, dbpath2);
641 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, reStorePath);
642 NAPI_ASSERT(env, errCode == 14800011, "OH_Rdb_Restore is success.");
643
644 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
645 cursor->getRowCount(cursor, &rowCount);
646 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
647
648 errCode = OH_Rdb_Restore(storeBackupTestRdbStore_, backupPath);
649 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Restore is fail.");
650
651 cursor = OH_Rdb_ExecuteQuery(storeBackupTestRdbStore_, querySql);
652 cursor->getRowCount(cursor, &rowCount);
653 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
654
655 valueBucket->destroy(valueBucket);
656 errCode = cursor->destroy(cursor);
657
658 napi_value returnCode;
659 napi_create_double(env, errCode, &returnCode);
660 return returnCode;
661 }
662
663
664
665
666 EXTERN_C_START
Init(napi_env env,napi_value exports)667 static napi_value Init(napi_env env, napi_value exports) {
668 napi_property_descriptor desc[] = {
669 {"RdbFilePath", nullptr, RdbFilePath, nullptr, nullptr, nullptr, napi_default, nullptr},
670 {"RdbstoreSetUpTestCase", nullptr, RdbstoreSetUpTestCase, nullptr, nullptr, nullptr, napi_default, nullptr},
671 {"RdbstoreTearDownTestCase", nullptr, RdbstoreTearDownTestCase, nullptr, nullptr, nullptr, napi_default, nullptr},
672 {"SUB_DDM_RDB_BackupRestoreTest_0100", nullptr, SUB_DDM_RDB_BackupRestoreTest_0100, nullptr, nullptr, nullptr, napi_default, nullptr},
673 {"SUB_DDM_RDB_BackupRestoreTest_0300", nullptr, SUB_DDM_RDB_BackupRestoreTest_0300, nullptr, nullptr, nullptr, napi_default, nullptr},
674 {"SUB_DDM_RDB_BackupRestoreTest_0400", nullptr, SUB_DDM_RDB_BackupRestoreTest_0400, nullptr, nullptr, nullptr, napi_default, nullptr},
675 {"SUB_DDM_RDB_BackupRestoreTest_0500", nullptr, SUB_DDM_RDB_BackupRestoreTest_0500, nullptr, nullptr, nullptr, napi_default, nullptr},
676 {"SUB_DDM_RDB_BackupRestoreTest_0600", nullptr, SUB_DDM_RDB_BackupRestoreTest_0600, nullptr, nullptr, nullptr, napi_default, nullptr},
677 {"SUB_DDM_RDB_BackupRestoreTest_0700", nullptr, SUB_DDM_RDB_BackupRestoreTest_0700, nullptr, nullptr, nullptr, napi_default, nullptr},
678 {"SUB_DDM_RDB_BackupRestoreTest_0800", nullptr, SUB_DDM_RDB_BackupRestoreTest_0800, nullptr, nullptr, nullptr, napi_default, nullptr},
679 {"SUB_DDM_RDB_BackupRestoreTest_0900", nullptr, SUB_DDM_RDB_BackupRestoreTest_0900, nullptr, nullptr, nullptr, napi_default, nullptr},
680 {"SUB_DDM_RDB_BackupRestoreTest_0110", nullptr, SUB_DDM_RDB_BackupRestoreTest_0110, nullptr, nullptr, nullptr, napi_default, nullptr}
681 };
682 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
683 return exports;
684 }
685 EXTERN_C_END
686
687
688
689 static napi_module demoModule = {
690 .nm_version = 1,
691 .nm_flags = 0,
692 .nm_filename = nullptr,
693 .nm_register_func = Init,
694 .nm_modname = "backup",
695 .nm_priv = ((void *)0),
696 .reserved = {0},
697 };
698
RegisterEntryModule(void)699 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) {
700 napi_module_register(&demoModule);
701 }
702