1 /*
2 * Copyright (c) 2024 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 napi_env g_env = 0;
37 char *RDB_TEST_PATH = NULL;
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 OH_Rdb_Store *storeTestRdbStore_ = NULL;
42 OH_Rdb_Store *storeTestRdbStore1_ = NULL;
43 OH_Rdb_Store *storeTestRdbStore2_ = NULL;
44
45 static OH_Rdb_Config config_;
InitRdbConfig()46 static void InitRdbConfig()
47 {
48 config_.dataBaseDir = RDB_TEST_PATH;
49 config_.storeName = RDB_STORE_NAME;
50 config_.bundleName = BUNDLE_NAME;
51 config_.moduleName = MODULE_NAME;
52 config_.securityLevel = OH_Rdb_SecurityLevel::S1;
53 config_.isEncrypt = false;
54 config_.area = Rdb_SecurityArea::RDB_SECURITY_AREA_EL1;
55 config_.selfSize = sizeof(OH_Rdb_Config);
56 }
57
58
RdbFilePath(napi_env env,napi_callback_info info)59 static napi_value RdbFilePath(napi_env env, napi_callback_info info) {
60 int errCode = 0;
61 size_t argc = 1;
62 napi_value args[1] = {nullptr};
63 napi_get_cb_info(env, info, &argc, args , nullptr, nullptr);
64
65 size_t bufferSize = 0;
66 napi_get_value_string_latin1(env, args[0], nullptr, 0, &bufferSize);
67
68 char *buffer = (char*)malloc((bufferSize) + 1);
69 napi_get_value_string_utf8(env, args[0], buffer, bufferSize+1, &bufferSize);
70
71 RDB_TEST_PATH = (char*)malloc((bufferSize) + 1);
72 sprintf(RDB_TEST_PATH, "%s", buffer);
73
74 napi_value returnCode;
75 napi_create_double(env, errCode, &returnCode);
76 return returnCode;
77 }
78
RdbstoreSetUpTestCase(napi_env env,napi_callback_info info)79 static napi_value RdbstoreSetUpTestCase(napi_env env, napi_callback_info info) {
80
81 InitRdbConfig();
82 mkdir(config_.dataBaseDir, 0770);
83
84 int errCode = 0;
85 storeTestRdbStore_ = OH_Rdb_GetOrOpen(&config_, &errCode);
86 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_GetOrOpen is fail.");
87 NAPI_ASSERT(env, storeTestRdbStore_ != NULL, "OH_Rdb_GetOrOpen config is fail.");
88
89 char createTableSql[] = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
90 "data3 FLOAT, data4 BLOB, data5 TEXT);";
91 errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
92 NAPI_ASSERT(env, errCode == 0, "createTable is fail.");
93
94 napi_value returnCode;
95 napi_create_double(env, errCode, &returnCode);
96 return returnCode;
97 }
98
RdbstoreTearDownTestCase(napi_env env,napi_callback_info info)99 static napi_value RdbstoreTearDownTestCase(napi_env env, napi_callback_info info) {
100 int errCode = 0;
101 char dropTableSql[] = "DROP TABLE IF EXISTS test";
102 OH_Rdb_Execute(storeTestRdbStore_, dropTableSql);
103 OH_Rdb_CloseStore(storeTestRdbStore_);
104 errCode = OH_Rdb_DeleteStore(&config_);
105
106 napi_value returnCode;
107 napi_create_double(env, errCode, &returnCode);
108 return returnCode;
109 }
110
ProgressCallback(void * context,Rdb_ProgressDetails * progressDetails)111 static void ProgressCallback(void *context, Rdb_ProgressDetails *progressDetails) {
112 NAPI_ASSERT_RETURN_VOID(g_env, progressDetails != nullptr, "progressDetails is fail.");
113 NAPI_ASSERT_RETURN_VOID(g_env, progressDetails->version == DISTRIBUTED_PROGRESS_DETAIL_VERSION, "version fail.");
114 NAPI_ASSERT_RETURN_VOID(g_env, progressDetails->schedule == Rdb_Progress::RDB_SYNC_FINISH, "schedule is fail.");
115 NAPI_ASSERT_RETURN_VOID(g_env, progressDetails->code == Rdb_ProgressCode::RDB_CLOUD_DISABLED, "code is fail.");
116 NAPI_ASSERT_RETURN_VOID(g_env, progressDetails->tableLength == 0, "tableLength is fail.");
117 Rdb_TableDetails *tableDetails = OH_Rdb_GetTableDetails(progressDetails, DISTRIBUTED_PROGRESS_DETAIL_VERSION);
118 NAPI_ASSERT_RETURN_VOID(g_env, tableDetails != nullptr, "tableDetails is fail.");
119 }
120
121 static Rdb_ProgressCallback callback = ProgressCallback;
122 static Rdb_ProgressObserver observer = { nullptr, callback };
123
124
RdbSubscribeDetailCallback(void * context,const Rdb_ChangeInfo ** changeInfo,uint32_t count)125 static void RdbSubscribeDetailCallback(void *context, const Rdb_ChangeInfo **changeInfo, uint32_t count)
126 {
127 NAPI_ASSERT_RETURN_VOID(g_env, count == 0, "count is fail.");
128 }
129
RdbSubscribeBriefCallback(void * context,const char * values[],uint32_t count)130 static void RdbSubscribeBriefCallback(void *context, const char *values[], uint32_t count)
131 {
132 NAPI_ASSERT_RETURN_VOID(g_env, count == 0, "count is fail.");
133 }
134
135 static Rdb_BriefObserver briefObserver = RdbSubscribeBriefCallback;
136 static Rdb_DetailsObserver detailObserver = RdbSubscribeDetailCallback;
137 static const Rdb_DataObserver briefObs = {.context = nullptr, .callback.briefObserver = briefObserver};
138 static const Rdb_DataObserver detailObs = {.context = nullptr, .callback.detailsObserver = detailObserver};
139
140 /**
141 * @tc.name: SUB_DDM_RDB_0100
142 * @tc.desc: napi test RDB store for Insert、Update、Query.
143 * @tc.type: FUNC
144 */
SUB_DDM_RDB_0100(napi_env env,napi_callback_info info)145 static napi_value SUB_DDM_RDB_0100(napi_env env, napi_callback_info info) {
146
147 int errCode = 0;
148 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
149 valueBucket->putInt64(valueBucket, "id", 1);
150 valueBucket->putText(valueBucket, "data1", "zhangSan");
151 valueBucket->putInt64(valueBucket, "data2", 12800);
152 valueBucket->putReal(valueBucket, "data3", 100.1);
153 uint8_t arr[] = {1, 2, 3, 4, 5};
154 int len = sizeof(arr) / sizeof(arr[0]);
155 valueBucket->putBlob(valueBucket, "data4", arr, len);
156 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
157 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
158 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
159
160 valueBucket->clear(valueBucket);
161 valueBucket->putText(valueBucket, "data1", "liSi");
162 valueBucket->putInt64(valueBucket, "data2", 13800);
163 valueBucket->putReal(valueBucket, "data3", 200.1);
164 valueBucket->putNull(valueBucket, "data5");
165
166 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
167 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
168 const char *data1Value = "zhangSan";
169 valueObject->putText(valueObject, data1Value);
170 predicates->equalTo(predicates, "data1", valueObject);
171 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
172 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Update is fail.");
173
174 predicates->clear(predicates);
175 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
176 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
177
178 int rowCount = 0;
179 cursor->getRowCount(cursor, &rowCount);
180 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
181
182 errCode = cursor->goToNextRow(cursor);
183 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
184
185 size_t size = 0;
186 cursor->getSize(cursor, 1, &size);
187 char data1Value_1[size + 1];
188 cursor->getText(cursor, 1, data1Value_1, size + 1);
189 NAPI_ASSERT(env, strncmp(data1Value_1, "liSi", size) == 0, "getText is fail.");
190
191 int64_t data2Value;
192 cursor->getInt64(cursor, 2, &data2Value);
193 NAPI_ASSERT(env, data2Value == 13800, "getInt64 is fail.");
194
195
196 double data3Value;
197 cursor->getReal(cursor, 3, &data3Value);
198 NAPI_ASSERT(env, data3Value == 200.1, "getReal is fail.");
199
200 cursor->getSize(cursor, 4, &size);
201 unsigned char data4Value[size];
202 cursor->getBlob(cursor, 4, data4Value, size);
203 NAPI_ASSERT(env, data4Value[0] == 1, "getBlob is fail.");
204 NAPI_ASSERT(env, data4Value[1] == 2, "getBlob is fail.");
205
206 bool isNull = false;
207 cursor->isNull(cursor, 5, &isNull);
208 NAPI_ASSERT(env, isNull == true, "isNull is fail.");
209
210 valueObject->destroy(valueObject);
211 valueBucket->destroy(valueBucket);
212 predicates->destroy(predicates);
213 errCode = cursor->destroy(cursor);
214
215 napi_value returnCode;
216 napi_create_double(env, errCode, &returnCode);
217 return returnCode;
218
219 }
220
221
222 /**
223 * @tc.name: SUB_DDM_RDB_0200
224 * @tc.desc: napi test RDB store for Insert with wrong table name or table is NULL.
225 * @tc.type: FUNC
226 */
SUB_DDM_RDB_0200(napi_env env,napi_callback_info info)227 static napi_value SUB_DDM_RDB_0200(napi_env env, napi_callback_info info) {
228 int errCode = 0;
229 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
230 valueBucket->putInt64(valueBucket, "id", 1);
231 valueBucket->putText(valueBucket, "data1", "zhangSan");
232 valueBucket->putInt64(valueBucket, "data2", 12800);
233 valueBucket->putReal(valueBucket, "data3", 100.1);
234 uint8_t arr[] = {1, 2, 3, 4, 5};
235 int len = sizeof(arr) / sizeof(arr[0]);
236 valueBucket->putBlob(valueBucket, "data4", arr, len);
237 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
238 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
239 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
240
241 valueBucket->clear(valueBucket);
242 valueBucket->putInt64(valueBucket, "id", 2);
243 valueBucket->putText(valueBucket, "data1", "liSi");
244 valueBucket->putInt64(valueBucket, "data2", 13800);
245 valueBucket->putReal(valueBucket, "data3", 200.1);
246 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
247 errCode = OH_Rdb_Insert(storeTestRdbStore_, "wrong", valueBucket);
248 NAPI_ASSERT(env, errCode == -1, "OH_Rdb_Insert id=2 is fail.");
249
250 valueBucket->clear(valueBucket);
251 valueBucket->putInt64(valueBucket, "id", 3);
252 valueBucket->putText(valueBucket, "data1", "wangWu");
253 valueBucket->putInt64(valueBucket, "data2", 14800);
254 valueBucket->putReal(valueBucket, "data3", 300.1);
255 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
256 char *table = NULL;
257 errCode = OH_Rdb_Insert(storeTestRdbStore_, table, valueBucket);
258 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, "OH_Rdb_Insert id=3 is fail.");
259
260 char querySql[] = "SELECT * FROM test";
261 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
262
263 int rowCount = 0;
264 cursor->getRowCount(cursor, &rowCount);
265 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
266
267 valueBucket->destroy(valueBucket);
268 errCode = cursor->destroy(cursor);
269
270 napi_value returnCode;
271 napi_create_double(env, errCode, &returnCode);
272 return returnCode;
273
274 }
275
276 /**
277 * @tc.name: SUB_DDM_RDB_0300
278 * @tc.desc: napi test RDB store for Update with wrong table or table is NULL.
279 * @tc.type: FUNC
280 */
SUB_DDM_RDB_0300(napi_env env,napi_callback_info info)281 static napi_value SUB_DDM_RDB_0300(napi_env env, napi_callback_info info) {
282 int errCode = 0;
283 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
284 valueBucket->putInt64(valueBucket, "id", 1);
285 valueBucket->putText(valueBucket, "data1", "zhangSan");
286 valueBucket->putInt64(valueBucket, "data2", 12800);
287 valueBucket->putReal(valueBucket, "data3", 100.1);
288 uint8_t arr[] = {1, 2, 3, 4, 5};
289 int len = sizeof(arr) / sizeof(arr[0]);
290 valueBucket->putBlob(valueBucket, "data4", arr, len);
291 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
292 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
293 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
294
295 valueBucket->clear(valueBucket);
296 valueBucket->putText(valueBucket, "data1", "liSi");
297 valueBucket->putInt64(valueBucket, "data2", 13800);
298 valueBucket->putReal(valueBucket, "data3", 200.1);
299 valueBucket->putNull(valueBucket, "data5");
300
301 OH_Predicates *predicates = OH_Rdb_CreatePredicates("wrong");
302 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
303 const char *data1Value = "zhangSan";
304 valueObject->putText(valueObject, data1Value);
305 predicates->equalTo(predicates, "data1", valueObject);
306 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
307 NAPI_ASSERT(env, errCode == -1, "OH_Rdb_Update is fail.");
308
309 char *table = NULL;
310 OH_Predicates *predicates1 = OH_Rdb_CreatePredicates(table);
311 NAPI_ASSERT(env, predicates1 == NULL, "OH_Rdb_CreatePredicates is fail.");
312 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates1);
313 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, "OH_Rdb_Update is fail.");
314
315 OH_Predicates *predicates2 = OH_Rdb_CreatePredicates("test");
316 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates2, NULL, 0);
317 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
318
319 int rowCount = 0;
320 cursor->getRowCount(cursor, &rowCount);
321 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
322
323 errCode = cursor->goToNextRow(cursor);
324 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
325
326 size_t size = 0;
327 cursor->getSize(cursor, 1, &size);
328 char data1Value_1[size + 1];
329 cursor->getText(cursor, 1, data1Value_1, size + 1);
330 NAPI_ASSERT(env, strncmp(data1Value_1, "zhangSan", size) == 0, "getText is fail.");
331
332 int64_t data2Value;
333 cursor->getInt64(cursor, 2, &data2Value);
334 NAPI_ASSERT(env, data2Value == 12800, "getInt64 is fail.");
335
336 double data3Value;
337 cursor->getReal(cursor, 3, &data3Value);
338 NAPI_ASSERT(env, data3Value == 100.1, "getReal is fail.");
339
340 cursor->getSize(cursor, 4, &size);
341 unsigned char data4Value[size];
342 cursor->getBlob(cursor, 4, data4Value, size);
343 NAPI_ASSERT(env, data4Value[0] == 1, "getBlob is fail.");
344 NAPI_ASSERT(env, data4Value[1] == 2, "getBlob is fail.");
345
346 cursor->getSize(cursor, 5, &size);
347 char data5Value[size + 1];
348 cursor->getText(cursor, 5, data5Value, size + 1);
349 NAPI_ASSERT(env, strncmp(data5Value, "ABCDEFG", size) == 0, "getText is fail.");
350
351 valueObject->destroy(valueObject);
352 predicates->destroy(predicates);
353 predicates2->destroy(predicates2);
354 valueBucket->destroy(valueBucket);
355 errCode = cursor->destroy(cursor);
356
357 napi_value returnCode;
358 napi_create_double(env, errCode, &returnCode);
359 return returnCode;
360
361 }
362
363 /**
364 * @tc.name: SUB_DDM_RDB_0400
365 * @tc.desc: napi test RDB store for Update with valueBucket is NULL.
366 * @tc.type: FUNC
367 */
SUB_DDM_RDB_0400(napi_env env,napi_callback_info info)368 static napi_value SUB_DDM_RDB_0400(napi_env env, napi_callback_info info) {
369 int errCode = 0;
370 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
371 valueBucket->putInt64(valueBucket, "id", 1);
372 valueBucket->putText(valueBucket, "data1", "zhangSan");
373 valueBucket->putInt64(valueBucket, "data2", 12800);
374 valueBucket->putReal(valueBucket, "data3", 100.1);
375 uint8_t arr[] = {1, 2, 3, 4, 5};
376 int len = sizeof(arr) / sizeof(arr[0]);
377 valueBucket->putBlob(valueBucket, "data4", arr, len);
378 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
379 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
380 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
381
382 valueBucket->clear(valueBucket);
383
384 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
385 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
386 const char *data1Value = "zhangSan";
387 valueObject->putText(valueObject, data1Value);
388 predicates->equalTo(predicates, "data1", valueObject);
389 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
390 NAPI_ASSERT(env, errCode == -1, "OH_Rdb_Update is fail.");
391
392 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
393 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
394
395 int rowCount = 0;
396 cursor->getRowCount(cursor, &rowCount);
397 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
398
399 errCode = cursor->goToNextRow(cursor);
400 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
401
402 size_t size = 0;
403 cursor->getSize(cursor, 1, &size);
404 char data1Value_1[size + 1];
405 cursor->getText(cursor, 1, data1Value_1, size + 1);
406 NAPI_ASSERT(env, strncmp(data1Value_1, "zhangSan", size) == 0, "getText is fail.");
407
408 valueObject->destroy(valueObject);
409 predicates->destroy(predicates);
410 valueBucket->destroy(valueBucket);
411 errCode = cursor->destroy(cursor);
412
413 napi_value returnCode;
414 napi_create_double(env, errCode, &returnCode);
415 return returnCode;
416 }
417
418 /**
419 * @tc.name: SUB_DDM_RDB_0500
420 * @tc.desc: napi test RDB store for Update with wrong predicates.
421 * @tc.type: FUNC
422 */
SUB_DDM_RDB_0500(napi_env env,napi_callback_info info)423 static napi_value SUB_DDM_RDB_0500(napi_env env, napi_callback_info info) {
424 int errCode = 0;
425 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
426 valueBucket->putInt64(valueBucket, "id", 1);
427 valueBucket->putText(valueBucket, "data1", "zhangSan");
428 valueBucket->putInt64(valueBucket, "data2", 12800);
429 valueBucket->putReal(valueBucket, "data3", 100.1);
430 uint8_t arr[] = {1, 2, 3, 4, 5};
431 int len = sizeof(arr) / sizeof(arr[0]);
432 valueBucket->putBlob(valueBucket, "data4", arr, len);
433 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
434 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
435 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
436
437 valueBucket->clear(valueBucket);
438 valueBucket->putText(valueBucket, "data1", "liSi");
439 valueBucket->putInt64(valueBucket, "data2", 13800);
440 valueBucket->putReal(valueBucket, "data3", 200.1);
441 valueBucket->putNull(valueBucket, "data5");
442
443 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
444 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
445 const char *data1Value = "wangwu";
446 valueObject->putText(valueObject, data1Value);
447 predicates->equalTo(predicates, "data1", valueObject);
448 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
449 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Update is fail.");
450
451 predicates->clear(predicates);
452 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
453 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
454
455 int rowCount = 0;
456 cursor->getRowCount(cursor, &rowCount);
457 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
458
459 errCode = cursor->goToNextRow(cursor);
460 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
461
462 size_t size = 0;
463 cursor->getSize(cursor, 1, &size);
464 char data1Value_1[size + 1];
465 cursor->getText(cursor, 1, data1Value_1, size + 1);
466 NAPI_ASSERT(env, strncmp(data1Value_1, "zhangSan", size) == 0, "getText is fail.");
467
468 valueObject->destroy(valueObject);
469 predicates->destroy(predicates);
470 valueBucket->destroy(valueBucket);
471 errCode = cursor->destroy(cursor);
472
473 napi_value returnCode;
474 napi_create_double(env, errCode, &returnCode);
475 return returnCode;
476 }
477
478 /**
479 * @tc.name: SUB_DDM_RDB_0600
480 * @tc.desc: napi test RDB store for Query with wrong table or table is NULL.
481 * @tc.type: FUNC
482 */
SUB_DDM_RDB_0600(napi_env env,napi_callback_info info)483 static napi_value SUB_DDM_RDB_0600(napi_env env, napi_callback_info info) {
484 int errCode = 0;
485 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
486 valueBucket->putInt64(valueBucket, "id", 1);
487 valueBucket->putText(valueBucket, "data1", "zhangSan");
488 valueBucket->putInt64(valueBucket, "data2", 12800);
489 valueBucket->putReal(valueBucket, "data3", 100.1);
490 uint8_t arr[] = {1, 2, 3, 4, 5};
491 int len = sizeof(arr) / sizeof(arr[0]);
492 valueBucket->putBlob(valueBucket, "data4", arr, len);
493 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
494 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
495 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
496
497 OH_Predicates *predicates = OH_Rdb_CreatePredicates("wrong");
498 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
499 const char *data1Value = "zhangSan";
500 valueObject->putText(valueObject, data1Value);
501 predicates->equalTo(predicates, "data1", valueObject);
502
503 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
504 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
505
506 char *table = NULL;
507 OH_Predicates *predicates1 = OH_Rdb_CreatePredicates(table);
508
509 OH_Cursor *cursor1 = OH_Rdb_Query(storeTestRdbStore_, predicates1, NULL, 0);
510 NAPI_ASSERT(env, cursor1 == NULL, "OH_Rdb_Query 2 is fail.");
511
512 valueObject->destroy(valueObject);
513 predicates->destroy(predicates);
514 valueBucket->destroy(valueBucket);
515 errCode = cursor->destroy(cursor);
516
517 napi_value returnCode;
518 napi_create_double(env, errCode, &returnCode);
519 return returnCode;
520 }
521
522 /**
523 * @tc.name: SUB_DDM_RDB_0700
524 * @tc.desc: napi test RDB store for Query with wrong columnNames.
525 * @tc.type: FUNC
526 */
SUB_DDM_RDB_0700(napi_env env,napi_callback_info info)527 static napi_value SUB_DDM_RDB_0700(napi_env env, napi_callback_info info) {
528 int errCode = 0;
529 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
530 valueBucket->putInt64(valueBucket, "id", 1);
531 valueBucket->putText(valueBucket, "data1", "zhangSan");
532 valueBucket->putInt64(valueBucket, "data2", 12800);
533 valueBucket->putReal(valueBucket, "data3", 100.1);
534 uint8_t arr[] = {1, 2, 3, 4, 5};
535 int len = sizeof(arr) / sizeof(arr[0]);
536 valueBucket->putBlob(valueBucket, "data4", arr, len);
537 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
538 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
539 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
540
541 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
542 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
543 const char *data1Value = "zhangSan";
544 valueObject->putText(valueObject, data1Value);
545 predicates->equalTo(predicates, "data1", valueObject);
546
547 const char *columnNames[] = {"data"};
548 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, columnNames, 1);
549 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
550
551 int rowCount = -1;
552 cursor->getRowCount(cursor, &rowCount);
553 NAPI_ASSERT(env, rowCount == -1, "getRowCount is fail.");
554
555 valueObject->destroy(valueObject);
556 predicates->destroy(predicates);
557 valueBucket->destroy(valueBucket);
558 errCode = cursor->destroy(cursor);
559
560 napi_value returnCode;
561 napi_create_double(env, errCode, &returnCode);
562 return returnCode;
563 }
564
565 /**
566 * @tc.name: SUB_DDM_RDB_0800
567 * @tc.desc: napi test RDB store for Query with wrong length.
568 * @tc.type: FUNC
569 */
SUB_DDM_RDB_0800(napi_env env,napi_callback_info info)570 static napi_value SUB_DDM_RDB_0800(napi_env env, napi_callback_info info) {
571 int errCode = 0;
572 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
573 valueBucket->putInt64(valueBucket, "id", 1);
574 valueBucket->putText(valueBucket, "data1", "zhangSan");
575 valueBucket->putInt64(valueBucket, "data2", 12800);
576 valueBucket->putReal(valueBucket, "data3", 100.1);
577 uint8_t arr[] = {1, 2, 3, 4, 5};
578 int len = sizeof(arr) / sizeof(arr[0]);
579 valueBucket->putBlob(valueBucket, "data4", arr, len);
580 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
581 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
582 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
583
584 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
585 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
586 const char *data1Value = "zhangSan";
587 valueObject->putText(valueObject, data1Value);
588 predicates->equalTo(predicates, "data1", valueObject);
589
590 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 1);
591 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
592
593 int rowCount = -1;
594 cursor->getRowCount(cursor, &rowCount);
595 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
596
597 valueObject->destroy(valueObject);
598 predicates->destroy(predicates);
599 valueBucket->destroy(valueBucket);
600 errCode = cursor->destroy(cursor);
601
602 napi_value returnCode;
603 napi_create_double(env, errCode, &returnCode);
604 return returnCode;
605 }
606
607 /**
608 * @tc.name: SUB_DDM_RDB_0900
609 * @tc.desc: napi test RDB store for Delete、ExecuteQuery.
610 * @tc.type: FUNC
611 */
SUB_DDM_RDB_0900(napi_env env,napi_callback_info info)612 static napi_value SUB_DDM_RDB_0900(napi_env env, napi_callback_info info) {
613 int errCode = 0;
614 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
615 valueBucket->putInt64(valueBucket, "id", 1);
616 valueBucket->putText(valueBucket, "data1", "zhangSan");
617 valueBucket->putInt64(valueBucket, "data2", 12800);
618 valueBucket->putReal(valueBucket, "data3", 100.1);
619 uint8_t arr[] = {1, 2, 3, 4, 5};
620 int len = sizeof(arr) / sizeof(arr[0]);
621 valueBucket->putBlob(valueBucket, "data4", arr, len);
622 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
623 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
624 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
625
626 valueBucket->clear(valueBucket);
627 valueBucket->putInt64(valueBucket, "id", 2);
628 valueBucket->putText(valueBucket, "data1", "liSi");
629 valueBucket->putInt64(valueBucket, "data2", 13800);
630 valueBucket->putReal(valueBucket, "data3", 200.1);
631 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
632 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
633 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert 2 is fail.");
634
635 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
636 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
637 const char *data1Value = "zhangSan";
638 valueObject->putText(valueObject, data1Value);
639 predicates->equalTo(predicates, "data1", valueObject);
640 errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates);
641 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Delete is fail.");
642
643 char querySql[] = "SELECT * FROM test";
644 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
645
646 int rowCount = 0;
647 cursor->getRowCount(cursor, &rowCount);
648 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
649
650 errCode = cursor->goToNextRow(cursor);
651 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
652
653 size_t size = 0;
654 cursor->getSize(cursor, 1, &size);
655 char data1Value_1[size + 1];
656 cursor->getText(cursor, 1, data1Value_1, size + 1);
657 NAPI_ASSERT(env, strncmp(data1Value_1, "liSi", 4) == 0, "getText is fail.");
658
659 int64_t data2Value;
660 cursor->getInt64(cursor, 2, &data2Value);
661 NAPI_ASSERT(env, data2Value == 13800, "getInt64 is fail.");
662
663 double data3Value;
664 cursor->getReal(cursor, 3, &data3Value);
665 NAPI_ASSERT(env, data3Value == 200.1, "getReal is fail.");
666
667 bool isNull = false;
668 cursor->isNull(cursor, 4, &isNull);
669 NAPI_ASSERT(env, isNull == true, "isNull is fail.");
670
671 cursor->getSize(cursor, 5, &size);
672 char data5Value[size + 1];
673 cursor->getText(cursor, 5, data5Value, size + 1);
674 NAPI_ASSERT(env, strncmp(data5Value, "ABCDEFGH", 8) == 0, "getText is fail.");
675
676 valueObject->destroy(valueObject);
677 valueBucket->destroy(valueBucket);
678 predicates->destroy(predicates);
679 errCode = cursor->destroy(cursor);
680
681 napi_value returnCode;
682 napi_create_double(env, errCode, &returnCode);
683 return returnCode;
684 }
685
686 /**
687 * @tc.name: SUB_DDM_RDB_1000
688 * @tc.desc: napi test RDB store for querysql is NULL.
689 * @tc.type: FUNC
690 */
SUB_DDM_RDB_1000(napi_env env,napi_callback_info info)691 static napi_value SUB_DDM_RDB_1000(napi_env env, napi_callback_info info) {
692 int errCode = 0;
693 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
694 valueBucket->putInt64(valueBucket, "id", 1);
695 valueBucket->putText(valueBucket, "data1", "zhangSan");
696 valueBucket->putInt64(valueBucket, "data2", 12800);
697 valueBucket->putReal(valueBucket, "data3", 100.1);
698 uint8_t arr[] = {1, 2, 3, 4, 5};
699 int len = sizeof(arr) / sizeof(arr[0]);
700 valueBucket->putBlob(valueBucket, "data4", arr, len);
701 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
702 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
703 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
704
705 char *querySql = NULL;
706 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
707 NAPI_ASSERT(env, cursor == NULL, "OH_Rdb_ExecuteQuery is fail.");
708
709 errCode = valueBucket->destroy(valueBucket);
710
711 napi_value returnCode;
712 napi_create_double(env, errCode, &returnCode);
713 return returnCode;
714 }
715
716 /**
717 * @tc.name: SUB_DDM_RDB_1100
718 * @tc.desc: napi test RDB store for Delete with wrong table or table is NULL.
719 * @tc.type: FUNC
720 */
SUB_DDM_RDB_1100(napi_env env,napi_callback_info info)721 static napi_value SUB_DDM_RDB_1100(napi_env env, napi_callback_info info) {
722 int errCode = 0;
723 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
724 valueBucket->putInt64(valueBucket, "id", 1);
725 valueBucket->putText(valueBucket, "data1", "zhangSan");
726 valueBucket->putInt64(valueBucket, "data2", 12800);
727 valueBucket->putReal(valueBucket, "data3", 100.1);
728 uint8_t arr[] = {1, 2, 3, 4, 5};
729 int len = sizeof(arr) / sizeof(arr[0]);
730 valueBucket->putBlob(valueBucket, "data4", arr, len);
731 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
732 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
733 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
734
735
736 valueBucket->clear(valueBucket);
737 valueBucket->putInt64(valueBucket, "id", 2);
738 valueBucket->putText(valueBucket, "data1", "liSi");
739 valueBucket->putInt64(valueBucket, "data2", 13800);
740 valueBucket->putReal(valueBucket, "data3", 200.1);
741 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
742 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
743 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert is fail.");
744
745 OH_Predicates *predicates = OH_Rdb_CreatePredicates("wrong");
746 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
747 const char *data1Value = "zhangSan";
748 valueObject->putText(valueObject, data1Value);
749 predicates->equalTo(predicates, "data1", valueObject);
750 errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates);
751 NAPI_ASSERT(env, errCode == -1, "OH_Rdb_Delete is fail.");
752
753 OH_Predicates *predicates1 = OH_Rdb_CreatePredicates("test");
754 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates1, NULL, 0);
755
756 int rowCount = 0;
757 cursor->getRowCount(cursor, &rowCount);
758 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
759
760 char *table = NULL;
761 OH_Predicates *predicates2 = OH_Rdb_CreatePredicates(table);
762 NAPI_ASSERT(env, predicates2 == NULL, "OH_Rdb_CreatePredicates is fail.");
763
764 errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates2);
765 NAPI_ASSERT(env, errCode == 14800001, "OH_Rdb_Delete is fail.");
766
767 OH_Cursor *cursor1 = OH_Rdb_Query(storeTestRdbStore_, predicates1, NULL, 0);
768 int rowCount1 = 0;
769 cursor1->getRowCount(cursor1, &rowCount1);
770 NAPI_ASSERT(env, rowCount1 == 2, "getRowCount is fail.");
771
772 valueObject->destroy(valueObject);
773 valueBucket->destroy(valueBucket);
774 predicates->destroy(predicates);
775 errCode = cursor->destroy(cursor);
776 cursor1->destroy(cursor1);
777
778 napi_value returnCode;
779 napi_create_double(env, errCode, &returnCode);
780 return returnCode;
781 }
782
783
784 /**
785 * @tc.name: SUB_DDM_RDB_1200
786 * @tc.desc: napi test RDB store for Delete with wrong predicates.
787 * @tc.type: FUNC
788 */
SUB_DDM_RDB_1200(napi_env env,napi_callback_info info)789 static napi_value SUB_DDM_RDB_1200(napi_env env, napi_callback_info info) {
790 int errCode = 0;
791 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
792 valueBucket->putInt64(valueBucket, "id", 1);
793 valueBucket->putText(valueBucket, "data1", "zhangSan");
794 valueBucket->putInt64(valueBucket, "data2", 12800);
795 valueBucket->putReal(valueBucket, "data3", 100.1);
796 uint8_t arr[] = {1, 2, 3, 4, 5};
797 int len = sizeof(arr) / sizeof(arr[0]);
798 valueBucket->putBlob(valueBucket, "data4", arr, len);
799 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
800 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
801 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
802
803 valueBucket->clear(valueBucket);
804 valueBucket->putInt64(valueBucket, "id", 2);
805 valueBucket->putText(valueBucket, "data1", "liSi");
806 valueBucket->putInt64(valueBucket, "data2", 13800);
807 valueBucket->putReal(valueBucket, "data3", 200.1);
808 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
809 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
810 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert is fail.");
811
812 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
813 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
814 const char *data1Value = "wangwu";
815 valueObject->putText(valueObject, data1Value);
816 predicates->equalTo(predicates, "data1", valueObject);
817 errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates);
818 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_Delete is fail.");
819
820 predicates->clear(predicates);
821 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
822 int rowCount = 0;
823 cursor->getRowCount(cursor, &rowCount);
824 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
825
826 valueObject->destroy(valueObject);
827 valueBucket->destroy(valueBucket);
828 predicates->destroy(predicates);
829 errCode = cursor->destroy(cursor);
830
831 napi_value returnCode;
832 napi_create_double(env, errCode, &returnCode);
833 return returnCode;
834 }
835
836
837
838 /**
839 * @tc.name: SUB_DDM_RDB_1300
840 * @tc.desc: napi test RDB store for Delete multiple.
841 * @tc.type: FUNC
842 */
SUB_DDM_RDB_1300(napi_env env,napi_callback_info info)843 static napi_value SUB_DDM_RDB_1300(napi_env env, napi_callback_info info) {
844 int errCode = 0;
845 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
846 valueBucket->putInt64(valueBucket, "id", 1);
847 valueBucket->putText(valueBucket, "data1", "zhangSan");
848 valueBucket->putInt64(valueBucket, "data2", 12800);
849 valueBucket->putReal(valueBucket, "data3", 100.1);
850 uint8_t arr[] = {1, 2, 3, 4, 5};
851 int len = sizeof(arr) / sizeof(arr[0]);
852 valueBucket->putBlob(valueBucket, "data4", arr, len);
853 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
854 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
855 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
856
857 valueBucket->clear(valueBucket);
858 valueBucket->putInt64(valueBucket, "id", 2);
859 valueBucket->putText(valueBucket, "data1", "zhangSan");
860 valueBucket->putInt64(valueBucket, "data2", 13800);
861 valueBucket->putReal(valueBucket, "data3", 200.1);
862 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
863 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
864 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert is fail.");
865
866 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
867 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
868 const char *data1Value = "zhangSan";
869 valueObject->putText(valueObject, data1Value);
870 predicates->equalTo(predicates, "data1", valueObject);
871 errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates);
872 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Delete is fail.");
873
874 predicates->clear(predicates);
875 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
876 int rowCount = 0;
877 cursor->getRowCount(cursor, &rowCount);
878 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
879
880 valueObject->destroy(valueObject);
881 valueBucket->destroy(valueBucket);
882 predicates->destroy(predicates);
883 errCode = cursor->destroy(cursor);
884
885 napi_value returnCode;
886 napi_create_double(env, errCode, &returnCode);
887 return returnCode;
888 }
889
890
891 /**
892 * @tc.name: SUB_DDM_RDB_1400
893 * @tc.desc: napi test RDB store for Transaction、Commit.
894 * @tc.type: FUNC
895 */
SUB_DDM_RDB_1400(napi_env env,napi_callback_info info)896 static napi_value SUB_DDM_RDB_1400(napi_env env, napi_callback_info info) {
897 int errCode = 0;
898 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
899 valueBucket->putInt64(valueBucket, "id", 1);
900 valueBucket->putText(valueBucket, "data1", "zhangSan");
901 valueBucket->putInt64(valueBucket, "data2", 12800);
902 valueBucket->putReal(valueBucket, "data3", 100.1);
903 uint8_t arr[] = {1, 2, 3, 4, 5};
904 int len = sizeof(arr) / sizeof(arr[0]);
905 valueBucket->putBlob(valueBucket, "data4", arr, len);
906 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
907 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
908 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
909
910 valueBucket->clear(valueBucket);
911 valueBucket->putInt64(valueBucket, "id", 2);
912 valueBucket->putText(valueBucket, "data1", "liSi");
913 valueBucket->putInt64(valueBucket, "data2", 13800);
914 valueBucket->putReal(valueBucket, "data3", 200.1);
915 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
916 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
917 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert is fail.");
918
919 OH_Rdb_Commit(storeTestRdbStore_);
920
921 char querySql[] = "SELECT * FROM test";
922 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
923
924 int rowCount = 0;
925 cursor->getRowCount(cursor, &rowCount);
926 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
927
928 valueBucket->destroy(valueBucket);
929 errCode = cursor->destroy(cursor);
930
931 napi_value returnCode;
932 napi_create_double(env, errCode, &returnCode);
933 return returnCode;
934 }
935
936 /**
937 * @tc.name: SUB_DDM_RDB_1500
938 * @tc.desc: napi test RDB store for Transaction、RollBack.
939 * @tc.type: FUNC
940 */
SUB_DDM_RDB_1500(napi_env env,napi_callback_info info)941 static napi_value SUB_DDM_RDB_1500(napi_env env, napi_callback_info info) {
942 int errCode = 0;
943 OH_Rdb_BeginTransaction(storeTestRdbStore_);
944
945 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
946 valueBucket->putInt64(valueBucket, "id", 1);
947 valueBucket->putText(valueBucket, "data1", "zhangSan");
948 valueBucket->putInt64(valueBucket, "data2", 12800);
949 valueBucket->putReal(valueBucket, "data3", 100.1);
950 uint8_t arr[] = {1, 2, 3, 4, 5};
951 int len = sizeof(arr) / sizeof(arr[0]);
952 valueBucket->putBlob(valueBucket, "data4", arr, len);
953 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
954 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
955 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
956
957
958 valueBucket->clear(valueBucket);
959 valueBucket->putInt64(valueBucket, "id", 2);
960 valueBucket->putText(valueBucket, "data1", "liSi");
961 valueBucket->putInt64(valueBucket, "data2", 13800);
962 valueBucket->putReal(valueBucket, "data3", 200.1);
963 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
964 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
965 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert is fail.");
966
967 OH_Rdb_RollBack(storeTestRdbStore_);
968
969 char querySql[] = "SELECT * FROM test";
970 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
971
972 int rowCount = 0;
973 cursor->getRowCount(cursor, &rowCount);
974 NAPI_ASSERT(env, rowCount == 0, "getRowCount is fail.");
975
976 valueBucket->destroy(valueBucket);
977 errCode = cursor->destroy(cursor);
978
979 napi_value returnCode;
980 napi_create_double(env, errCode, &returnCode);
981 return returnCode;
982 }
983
984
985 /**
986 * @tc.name: SUB_DDM_RDB_1600
987 * @tc.desc: napi test RDB store for Transaction、Commit.
988 * @tc.type: FUNC
989 */
SUB_DDM_RDB_1600(napi_env env,napi_callback_info info)990 static napi_value SUB_DDM_RDB_1600(napi_env env, napi_callback_info info) {
991 int errCode = 0;
992 OH_Rdb_BeginTransaction(storeTestRdbStore_);
993
994 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
995 valueBucket->putInt64(valueBucket, "id", 1);
996 valueBucket->putText(valueBucket, "data1", "zhangSan");
997 valueBucket->putInt64(valueBucket, "data2", 12800);
998 valueBucket->putReal(valueBucket, "data3", 100.1);
999 uint8_t arr[] = {1, 2, 3, 4, 5};
1000 int len = sizeof(arr) / sizeof(arr[0]);
1001 valueBucket->putBlob(valueBucket, "data4", arr, len);
1002 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1003 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1004 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1005
1006 OH_Rdb_BeginTransaction(storeTestRdbStore_);
1007
1008 valueBucket->clear(valueBucket);
1009 valueBucket->putInt64(valueBucket, "id", 2);
1010 valueBucket->putText(valueBucket, "data1", "liSi");
1011 valueBucket->putInt64(valueBucket, "data2", 13800);
1012 valueBucket->putReal(valueBucket, "data3", 200.1);
1013 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
1014 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1015 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert is fail.");
1016
1017 OH_Rdb_Commit(storeTestRdbStore_);
1018 OH_Rdb_Commit(storeTestRdbStore_);
1019
1020 char querySql[] = "SELECT * FROM test";
1021 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
1022
1023 int rowCount = 0;
1024 cursor->getRowCount(cursor, &rowCount);
1025 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
1026
1027 valueBucket->destroy(valueBucket);
1028 errCode = cursor->destroy(cursor);
1029
1030 napi_value returnCode;
1031 napi_create_double(env, errCode, &returnCode);
1032 return returnCode;
1033 }
1034
1035
1036 /**
1037 * @tc.name: SUB_DDM_RDB_1700
1038 * @tc.desc: napi test RDB store for Transaction、Commit.
1039 * @tc.type: FUNC
1040 */
SUB_DDM_RDB_1700(napi_env env,napi_callback_info info)1041 static napi_value SUB_DDM_RDB_1700(napi_env env, napi_callback_info info) {
1042 int errCode = 0;
1043 OH_Rdb_BeginTransaction(storeTestRdbStore_);
1044
1045 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1046 valueBucket->putInt64(valueBucket, "id", 1);
1047 valueBucket->putText(valueBucket, "data1", "zhangSan");
1048 valueBucket->putInt64(valueBucket, "data2", 12800);
1049 valueBucket->putReal(valueBucket, "data3", 100.1);
1050 uint8_t arr[] = {1, 2, 3, 4, 5};
1051 int len = sizeof(arr) / sizeof(arr[0]);
1052 valueBucket->putBlob(valueBucket, "data4", arr, len);
1053 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1054 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1055 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1056
1057 OH_Rdb_BeginTransaction(storeTestRdbStore_);
1058
1059 valueBucket->clear(valueBucket);
1060 valueBucket->putInt64(valueBucket, "id", 2);
1061 valueBucket->putText(valueBucket, "data1", "liSi");
1062 valueBucket->putInt64(valueBucket, "data2", 13800);
1063 valueBucket->putReal(valueBucket, "data3", 200.1);
1064 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
1065 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1066 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert is fail.");
1067
1068 OH_Rdb_RollBack(storeTestRdbStore_);
1069 OH_Rdb_Commit(storeTestRdbStore_);
1070
1071 char querySql[] = "SELECT * FROM test";
1072 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
1073
1074 int rowCount = 0;
1075 cursor->getRowCount(cursor, &rowCount);
1076 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1077
1078 valueBucket->destroy(valueBucket);
1079 errCode = cursor->destroy(cursor);
1080
1081 napi_value returnCode;
1082 napi_create_double(env, errCode, &returnCode);
1083 return returnCode;
1084 }
1085
1086
1087 /**
1088 * @tc.name: SUB_DDM_RDB_1800
1089 * @tc.desc: napi test RDB store for GetVersion、SetVersion.
1090 * @tc.type: FUNC
1091 */
SUB_DDM_RDB_1800(napi_env env,napi_callback_info info)1092 static napi_value SUB_DDM_RDB_1800(napi_env env, napi_callback_info info) {
1093 int errCode = 0;
1094 int version = 0;
1095 int setVersion = 3;
1096 errCode = OH_Rdb_GetVersion(storeTestRdbStore_, &version);
1097 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_GetVersion is fail.");
1098 NAPI_ASSERT(env, version == 0, "OH_Rdb_GetVersion is fail.");
1099
1100 errCode = OH_Rdb_SetVersion(storeTestRdbStore_, setVersion);
1101 errCode = OH_Rdb_GetVersion(storeTestRdbStore_, &version);
1102 NAPI_ASSERT(env, errCode == 0, "OH_Rdb_SetVersion is fail.");
1103 NAPI_ASSERT(env, version == 3, "OH_Rdb_SetVersion is fail.");
1104
1105 napi_value returnCode;
1106 napi_create_double(env, errCode, &returnCode);
1107 return returnCode;
1108 }
1109
1110
1111 /**
1112 * @tc.name: SUB_DDM_RDB_1900
1113 * @tc.desc: napi test RDB store for Query with wrong columnNames.
1114 * @tc.type: FUNC
1115 */
SUB_DDM_RDB_1900(napi_env env,napi_callback_info info)1116 static napi_value SUB_DDM_RDB_1900(napi_env env, napi_callback_info info) {
1117 int errCode = 0;
1118 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1119 valueBucket->putInt64(valueBucket, "id", 1);
1120 valueBucket->putText(valueBucket, "data1", "zhangSan");
1121 valueBucket->putInt64(valueBucket, "data2", 12800);
1122 valueBucket->putReal(valueBucket, "data3", 100.1);
1123 uint8_t arr[] = {1, 2, 3, 4, 5};
1124 int len = sizeof(arr) / sizeof(arr[0]);
1125 valueBucket->putBlob(valueBucket, "data4", arr, len);
1126 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1127 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1128 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1129
1130
1131 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1132 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1133 const char *data1Value = "zhangSan";
1134 valueObject->putText(valueObject, data1Value);
1135 predicates->equalTo(predicates, "data1", valueObject);
1136
1137 const char *columnNames[] = {"data1"};
1138 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, columnNames, 1);
1139 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1140
1141 int rowCount = -1;
1142 cursor->getRowCount(cursor, &rowCount);
1143 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1144
1145 valueObject->destroy(valueObject);
1146 predicates->destroy(predicates);
1147 valueBucket->destroy(valueBucket);
1148 errCode = cursor->destroy(cursor);
1149
1150 napi_value returnCode;
1151 napi_create_double(env, errCode, &returnCode);
1152 return returnCode;
1153 }
1154
1155
1156 /**
1157 * @tc.name: SUB_DDM_RDB_2000
1158 * @tc.desc: napi test RDB store for Update with wrong columnNames.
1159 * @tc.type: FUNC
1160 */
SUB_DDM_RDB_2000(napi_env env,napi_callback_info info)1161 static napi_value SUB_DDM_RDB_2000(napi_env env, napi_callback_info info) {
1162 int errCode = 0;
1163 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1164 valueBucket->putInt64(valueBucket, "id", 1);
1165 valueBucket->putText(valueBucket, "data1", "zhangSan");
1166 valueBucket->putInt64(valueBucket, "data2", 12800);
1167 valueBucket->putReal(valueBucket, "data3", 100.1);
1168 uint8_t arr[] = {1, 2, 3, 4, 5};
1169 int len = sizeof(arr) / sizeof(arr[0]);
1170 valueBucket->putBlob(valueBucket, "data4", arr, len);
1171 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1172 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1173 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1174
1175 valueBucket->clear(valueBucket);
1176 valueBucket->putText(valueBucket, "data1", "liSi");
1177 valueBucket->putInt64(valueBucket, "data2", 13800);
1178 valueBucket->putReal(valueBucket, "data3", 200.1);
1179 valueBucket->putNull(valueBucket, "data5");
1180
1181 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1182 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1183 const char *data1Value = "zhangSan";
1184 valueObject->putText(valueObject, data1Value);
1185 predicates->equalTo(predicates, "data", valueObject);
1186 errCode = OH_Rdb_Update(storeTestRdbStore_, valueBucket, predicates);
1187 NAPI_ASSERT(env, errCode == -1, "OH_Rdb_Update is fail.");
1188
1189 predicates->clear(predicates);
1190 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
1191 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1192
1193 int rowCount = 0;
1194 cursor->getRowCount(cursor, &rowCount);
1195 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1196
1197 errCode = cursor->goToNextRow(cursor);
1198 NAPI_ASSERT(env, errCode == 0, "goToNextRow is fail.");
1199
1200 size_t size = 0;
1201 cursor->getSize(cursor, 1, &size);
1202 char data1Value_1[size + 1];
1203 cursor->getText(cursor, 1, data1Value_1, size + 1);
1204 NAPI_ASSERT(env, strncmp(data1Value_1, "zhangSan", size) == 0, "getText is fail.");
1205
1206 valueObject->destroy(valueObject);
1207 predicates->destroy(predicates);
1208 valueBucket->destroy(valueBucket);
1209 errCode = cursor->destroy(cursor);
1210
1211 napi_value returnCode;
1212 napi_create_double(env, errCode, &returnCode);
1213 return returnCode;
1214 }
1215
1216
1217 /**
1218 * @tc.name: SUB_DDM_RDB_2100
1219 * @tc.desc: napi test RDB store for Delete with wrong columnNames.
1220 * @tc.type: FUNC
1221 */
SUB_DDM_RDB_2100(napi_env env,napi_callback_info info)1222 static napi_value SUB_DDM_RDB_2100(napi_env env, napi_callback_info info) {
1223 int errCode = 0;
1224 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1225 valueBucket->putInt64(valueBucket, "id", 1);
1226 valueBucket->putText(valueBucket, "data1", "zhangSan");
1227 valueBucket->putInt64(valueBucket, "data2", 12800);
1228 valueBucket->putReal(valueBucket, "data3", 100.1);
1229 uint8_t arr[] = {1, 2, 3, 4, 5};
1230 int len = sizeof(arr) / sizeof(arr[0]);
1231 valueBucket->putBlob(valueBucket, "data4", arr, len);
1232 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1233 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1234 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1235
1236 valueBucket->clear(valueBucket);
1237 valueBucket->putInt64(valueBucket, "id", 2);
1238 valueBucket->putText(valueBucket, "data1", "liSi");
1239 valueBucket->putInt64(valueBucket, "data2", 13800);
1240 valueBucket->putReal(valueBucket, "data3", 200.1);
1241 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
1242 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1243 NAPI_ASSERT(env, errCode == 2, "OH_Rdb_Insert is fail.");
1244
1245 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1246 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1247 const char *data1Value = "zhangSan";
1248 valueObject->putText(valueObject, data1Value);
1249 predicates->equalTo(predicates, "data", valueObject);
1250 errCode = OH_Rdb_Delete(storeTestRdbStore_, predicates);
1251 NAPI_ASSERT(env, errCode == -1, "OH_Rdb_Delete is fail.");
1252
1253 predicates->clear(predicates);
1254 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 0);
1255 int rowCount = 0;
1256 cursor->getRowCount(cursor, &rowCount);
1257 NAPI_ASSERT(env, rowCount == 2, "getRowCount is fail.");
1258
1259 valueObject->destroy(valueObject);
1260 valueBucket->destroy(valueBucket);
1261 predicates->destroy(predicates);
1262 errCode = cursor->destroy(cursor);
1263
1264 napi_value returnCode;
1265 napi_create_double(env, errCode, &returnCode);
1266 return returnCode;
1267 }
1268
1269
1270 /**
1271 * @tc.name: SUB_DDM_RDB_2200
1272 * @tc.desc: napi test RDB store for Query with wrong length.
1273 * @tc.type: FUNC
1274 */
SUB_DDM_RDB_2200(napi_env env,napi_callback_info info)1275 static napi_value SUB_DDM_RDB_2200(napi_env env, napi_callback_info info) {
1276 int errCode = 0;
1277 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1278 valueBucket->putInt64(valueBucket, "id", 1);
1279 valueBucket->putText(valueBucket, "data1", "zhangSan");
1280 valueBucket->putInt64(valueBucket, "data2", 12800);
1281 valueBucket->putReal(valueBucket, "data3", 100.1);
1282 uint8_t arr[] = {1, 2, 3, 4, 5};
1283 int len = sizeof(arr) / sizeof(arr[0]);
1284 valueBucket->putBlob(valueBucket, "data4", arr, len);
1285 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1286 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1287 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1288
1289 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1290 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1291 const char *data1Value = "zhangSan";
1292 valueObject->putText(valueObject, data1Value);
1293 predicates->equalTo(predicates, "data1", valueObject);
1294
1295 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 2);
1296 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1297
1298 int rowCount = -1;
1299 cursor->getRowCount(cursor, &rowCount);
1300 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1301
1302 valueObject->destroy(valueObject);
1303 predicates->destroy(predicates);
1304 valueBucket->destroy(valueBucket);
1305 errCode = cursor->destroy(cursor);
1306
1307 napi_value returnCode;
1308 napi_create_double(env, errCode, &returnCode);
1309 return returnCode;
1310 }
1311
1312
1313 /**
1314 * @tc.name: SUB_DDM_RDB_2300
1315 * @tc.desc: napi test RDB store for Query with wrong length.
1316 * @tc.type: FUNC
1317 */
SUB_DDM_RDB_2300(napi_env env,napi_callback_info info)1318 static napi_value SUB_DDM_RDB_2300(napi_env env, napi_callback_info info) {
1319 int errCode = 0;
1320 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1321 valueBucket->putInt64(valueBucket, "id", 1);
1322 valueBucket->putText(valueBucket, "data1", "zhangSan");
1323 valueBucket->putInt64(valueBucket, "data2", 12800);
1324 valueBucket->putReal(valueBucket, "data3", 100.1);
1325 uint8_t arr[] = {1, 2, 3, 4, 5};
1326 int len = sizeof(arr) / sizeof(arr[0]);
1327 valueBucket->putBlob(valueBucket, "data4", arr, len);
1328 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1329 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1330 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1331
1332 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1333 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1334 const char *data1Value = "zhangSan";
1335 valueObject->putText(valueObject, data1Value);
1336 predicates->equalTo(predicates, "data1", valueObject);
1337
1338 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 7);
1339 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1340
1341 int rowCount = -1;
1342 cursor->getRowCount(cursor, &rowCount);
1343 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1344
1345 valueObject->destroy(valueObject);
1346 predicates->destroy(predicates);
1347 valueBucket->destroy(valueBucket);
1348 errCode = cursor->destroy(cursor);
1349
1350 napi_value returnCode;
1351 napi_create_double(env, errCode, &returnCode);
1352 return returnCode;
1353 }
1354
1355
1356 /**
1357 * @tc.name: SUB_DDM_RDB_2400
1358 * @tc.desc: napi test RDB store for Query with wrong length.
1359 * @tc.type: FUNC
1360 */
SUB_DDM_RDB_2400(napi_env env,napi_callback_info info)1361 static napi_value SUB_DDM_RDB_2400(napi_env env, napi_callback_info info) {
1362 int errCode = 0;
1363 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1364 valueBucket->putInt64(valueBucket, "id", 1);
1365 valueBucket->putText(valueBucket, "data1", "zhangSan");
1366 valueBucket->putInt64(valueBucket, "data2", 12800);
1367 valueBucket->putReal(valueBucket, "data3", 100.1);
1368 uint8_t arr[] = {1, 2, 3, 4, 5};
1369 int len = sizeof(arr) / sizeof(arr[0]);
1370 valueBucket->putBlob(valueBucket, "data4", arr, len);
1371 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1372 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1373 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1374
1375 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1376 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1377 const char *data1Value = "zhangSan";
1378 valueObject->putText(valueObject, data1Value);
1379 predicates->equalTo(predicates, "data1", valueObject);
1380
1381 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, NULL, 1);
1382 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1383
1384 int rowCount = -1;
1385 cursor->getRowCount(cursor, &rowCount);
1386 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1387
1388 valueObject->destroy(valueObject);
1389 predicates->destroy(predicates);
1390 valueBucket->destroy(valueBucket);
1391 errCode = cursor->destroy(cursor);
1392
1393 napi_value returnCode;
1394 napi_create_double(env, errCode, &returnCode);
1395 return returnCode;
1396 }
1397
1398
1399 /**
1400 * @tc.name: SUB_DDM_RDB_2500
1401 * @tc.desc: napi test RDB store for Query with wrong length.
1402 * @tc.type: FUNC
1403 */
SUB_DDM_RDB_2500(napi_env env,napi_callback_info info)1404 static napi_value SUB_DDM_RDB_2500(napi_env env, napi_callback_info info) {
1405 int errCode = 0;
1406 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1407 valueBucket->putInt64(valueBucket, "id", 1);
1408 valueBucket->putText(valueBucket, "data1", "zhangSan");
1409 valueBucket->putInt64(valueBucket, "data2", 12800);
1410 valueBucket->putReal(valueBucket, "data3", 100.1);
1411 uint8_t arr[] = {1, 2, 3, 4, 5};
1412 int len = sizeof(arr) / sizeof(arr[0]);
1413 valueBucket->putBlob(valueBucket, "data4", arr, len);
1414 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1415 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1416 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1417
1418
1419 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1420 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1421 const char *data1Value = "zhangSan";
1422 valueObject->putText(valueObject, data1Value);
1423 predicates->equalTo(predicates, "data1", valueObject);
1424
1425 const char *columnNames[] = {"data1","data2","data3","data4"};
1426 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, columnNames, 0);
1427 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1428
1429 int rowCount = -1;
1430 cursor->getRowCount(cursor, &rowCount);
1431 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1432
1433 valueObject->destroy(valueObject);
1434 predicates->destroy(predicates);
1435 valueBucket->destroy(valueBucket);
1436 errCode = cursor->destroy(cursor);
1437
1438 napi_value returnCode;
1439 napi_create_double(env, errCode, &returnCode);
1440 return returnCode;
1441 }
1442
1443
1444 /**
1445 * @tc.name: SUB_DDM_RDB_2600
1446 * @tc.desc: napi test RDB store for Query with wrong length.
1447 * @tc.type: FUNC
1448 */
SUB_DDM_RDB_2600(napi_env env,napi_callback_info info)1449 static napi_value SUB_DDM_RDB_2600(napi_env env, napi_callback_info info) {
1450 int errCode = 0;
1451 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1452 valueBucket->putInt64(valueBucket, "id", 1);
1453 valueBucket->putText(valueBucket, "data1", "zhangSan");
1454 valueBucket->putInt64(valueBucket, "data2", 12800);
1455 valueBucket->putReal(valueBucket, "data3", 100.1);
1456 uint8_t arr[] = {1, 2, 3, 4, 5};
1457 int len = sizeof(arr) / sizeof(arr[0]);
1458 valueBucket->putBlob(valueBucket, "data4", arr, len);
1459 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1460 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1461 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1462
1463 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1464 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1465 const char *data1Value = "zhangSan";
1466 valueObject->putText(valueObject, data1Value);
1467 predicates->equalTo(predicates, "data1", valueObject);
1468
1469 const char *columnNames[] = {"data1","data2","data3","data4"};
1470 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, columnNames, 1);
1471 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1472
1473 int rowCount = -1;
1474 cursor->getRowCount(cursor, &rowCount);
1475 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1476
1477 valueObject->destroy(valueObject);
1478 predicates->destroy(predicates);
1479 valueBucket->destroy(valueBucket);
1480 errCode = cursor->destroy(cursor);
1481
1482 napi_value returnCode;
1483 napi_create_double(env, errCode, &returnCode);
1484 return returnCode;
1485 }
1486
1487
1488 /**
1489 * @tc.name: SUB_DDM_RDB_2700
1490 * @tc.desc: napi test RDB store for Query with wrong length.
1491 * @tc.type: FUNC
1492 */
SUB_DDM_RDB_2700(napi_env env,napi_callback_info info)1493 static napi_value SUB_DDM_RDB_2700(napi_env env, napi_callback_info info) {
1494 int errCode = 0;
1495 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1496 valueBucket->putInt64(valueBucket, "id", 1);
1497 valueBucket->putText(valueBucket, "data1", "zhangSan");
1498 valueBucket->putInt64(valueBucket, "data2", 12800);
1499 valueBucket->putReal(valueBucket, "data3", 100.1);
1500 uint8_t arr[] = {1, 2, 3, 4, 5};
1501 int len = sizeof(arr) / sizeof(arr[0]);
1502 valueBucket->putBlob(valueBucket, "data4", arr, len);
1503 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1504 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1505 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1506
1507 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1508 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1509 const char *data1Value = "zhangSan";
1510 valueObject->putText(valueObject, data1Value);
1511 predicates->equalTo(predicates, "data1", valueObject);
1512
1513 const char *columnNames[] = {"data1","data2","data3","data4"};
1514 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, columnNames, 2);
1515 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1516 int rowCount = -1;
1517 cursor->getRowCount(cursor, &rowCount);
1518 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1519
1520 valueObject->destroy(valueObject);
1521 predicates->destroy(predicates);
1522 valueBucket->destroy(valueBucket);
1523 errCode = cursor->destroy(cursor);
1524
1525 napi_value returnCode;
1526 napi_create_double(env, errCode, &returnCode);
1527 return returnCode;
1528 }
1529
1530 /**
1531 * @tc.name: SUB_DDM_RDB_2800
1532 * @tc.desc: napi test RDB store for Query with wrong length.
1533 * @tc.type: FUNC
1534 */
SUB_DDM_RDB_2800(napi_env env,napi_callback_info info)1535 static napi_value SUB_DDM_RDB_2800(napi_env env, napi_callback_info info) {
1536 int errCode = 0;
1537 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1538 valueBucket->putInt64(valueBucket, "id", 1);
1539 valueBucket->putText(valueBucket, "data1", "zhangSan");
1540 valueBucket->putInt64(valueBucket, "data2", 12800);
1541 valueBucket->putReal(valueBucket, "data3", 100.1);
1542 uint8_t arr[] = {1, 2, 3, 4, 5};
1543 int len = sizeof(arr) / sizeof(arr[0]);
1544 valueBucket->putBlob(valueBucket, "data4", arr, len);
1545 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1546 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1547 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1548
1549 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1550 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1551 const char *data1Value = "zhangSan";
1552 valueObject->putText(valueObject, data1Value);
1553 predicates->equalTo(predicates, "data1", valueObject);
1554
1555 const char *columnNames[] = {"data1","data2","data3","data4"};
1556 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, columnNames, 4);
1557 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1558 int rowCount = -1;
1559 cursor->getRowCount(cursor, &rowCount);
1560 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1561
1562 valueObject->destroy(valueObject);
1563 predicates->destroy(predicates);
1564 valueBucket->destroy(valueBucket);
1565 errCode = cursor->destroy(cursor);
1566
1567 napi_value returnCode;
1568 napi_create_double(env, errCode, &returnCode);
1569 return returnCode;
1570 }
1571 /**
1572 * @tc.name: SUB_DDM_RDB_2900
1573 * @tc.desc: napi test RDB store for Query with wrong length.
1574 * @tc.type: FUNC
1575 */
SUB_DDM_RDB_2900(napi_env env,napi_callback_info info)1576 static napi_value SUB_DDM_RDB_2900(napi_env env, napi_callback_info info) {
1577 int errCode = 0;
1578 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1579 valueBucket->putInt64(valueBucket, "id", 1);
1580 valueBucket->putText(valueBucket, "data1", "zhangSan");
1581 valueBucket->putInt64(valueBucket, "data2", 12800);
1582 valueBucket->putReal(valueBucket, "data3", 100.1);
1583 uint8_t arr[] = {1, 2, 3, 4, 5};
1584 int len = sizeof(arr) / sizeof(arr[0]);
1585 valueBucket->putBlob(valueBucket, "data4", arr, len);
1586 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1587 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1588 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1589
1590 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1591 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1592 const char *data1Value = "zhangSan";
1593 valueObject->putText(valueObject, data1Value);
1594 predicates->equalTo(predicates, "data1", valueObject);
1595
1596 const char *columnNames[] = {"data2","data3","data4"};
1597 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, columnNames, 3);
1598 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1599 int rowCount = -1;
1600 cursor->getRowCount(cursor, &rowCount);
1601 NAPI_ASSERT(env, rowCount == 1, "getRowCount is fail.");
1602
1603 valueObject->destroy(valueObject);
1604 predicates->destroy(predicates);
1605 valueBucket->destroy(valueBucket);
1606 errCode = cursor->destroy(cursor);
1607
1608 napi_value returnCode;
1609 napi_create_double(env, errCode, &returnCode);
1610 return returnCode;
1611 }
1612 /**
1613 * @tc.name: SUB_DDM_RDB_3000
1614 * @tc.desc: napi test RDB store for Query with wrong length.
1615 * @tc.type: FUNC
1616 */
SUB_DDM_RDB_3000(napi_env env,napi_callback_info info)1617 static napi_value SUB_DDM_RDB_3000(napi_env env, napi_callback_info info) {
1618 int errCode = 0;
1619 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1620 valueBucket->putInt64(valueBucket, "id", 1);
1621 valueBucket->putText(valueBucket, "data1", "zhangSan");
1622 valueBucket->putInt64(valueBucket, "data2", 12800);
1623 valueBucket->putReal(valueBucket, "data3", 100.1);
1624 uint8_t arr[] = {1, 2, 3, 4, 5};
1625 int len = sizeof(arr) / sizeof(arr[0]);
1626 valueBucket->putBlob(valueBucket, "data4", arr, len);
1627 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1628 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1629 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1630
1631 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1632 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1633 const char *data1Value = "zhangSan";
1634 valueObject->putText(valueObject, data1Value);
1635 predicates->equalTo(predicates, "data1", valueObject);
1636
1637 const char *columnNames[] = {"data1","data2","data3","data4","data5"};
1638 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, columnNames, 5);
1639 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1640
1641 valueObject->destroy(valueObject);
1642 predicates->destroy(predicates);
1643 errCode = valueBucket->destroy(valueBucket);
1644
1645 napi_value returnCode;
1646 napi_create_double(env, errCode, &returnCode);
1647 return returnCode;
1648 }
1649
1650 /**
1651 * @tc.name: SUB_DDM_RDB_3100
1652 * @tc.desc: napi test RDB store for id
1653 * @tc.type: FUNC
1654 */
SUB_DDM_RDB_3100(napi_env env,napi_callback_info info)1655 static napi_value SUB_DDM_RDB_3100(napi_env env, napi_callback_info info) {
1656 int errCode = 0;
1657 OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
1658 valueBucket->putInt64(valueBucket, "id", 1);
1659 valueBucket->putText(valueBucket, "data1", "zhangSan");
1660 valueBucket->putInt64(valueBucket, "data2", 12800);
1661 valueBucket->putReal(valueBucket, "data3", 100.1);
1662 uint8_t arr[] = {1, 2, 3, 4, 5};
1663 int len = sizeof(arr) / sizeof(arr[0]);
1664 valueBucket->putBlob(valueBucket, "data4", arr, len);
1665 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
1666 errCode = OH_Rdb_Insert(storeTestRdbStore_, "test", valueBucket);
1667 NAPI_ASSERT(env, errCode == 1, "OH_Rdb_Insert is fail.");
1668
1669 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
1670 OH_VObject *valueObject = OH_Rdb_CreateValueObject();
1671 const char *data1Value = "zhangSan";
1672 valueObject->putText(valueObject, data1Value);
1673 predicates->equalTo(predicates, "data1", valueObject);
1674
1675 const char *columnNames[] = {"data1","data2","data3","data4","data5"};
1676 OH_Cursor *cursor = OH_Rdb_Query(storeTestRdbStore_, predicates, columnNames, 5);
1677 NAPI_ASSERT(env, cursor != NULL, "OH_Rdb_Query is fail.");
1678
1679 errCode = valueBucket->capability;
1680 NAPI_ASSERT(env, errCode == 6, "valueBucket capabilityis fail.");
1681
1682 int valueObjectID = valueObject->id;
1683 int valueBucketID = valueBucket->id;
1684 int predicatesID = predicates->id;
1685 int cursorID = cursor->id;
1686 int rdbID = storeTestRdbStore_->id;
1687
1688 valueObject->id = 11;
1689 valueBucket->id = 12;
1690 predicates->id = 13;
1691 cursor->id = 14;
1692 storeTestRdbStore_->id = 15;
1693
1694 errCode = valueObject->destroy(valueObject);
1695 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, "valueObject id is fail.");
1696 errCode = valueBucket->destroy(valueBucket);
1697 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, "valueBucket id is fail.");
1698 errCode = predicates->destroy(predicates);
1699 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, "predicates id is fail.");
1700 errCode = cursor->destroy(cursor);
1701 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, "cursor id is fail.");
1702 errCode = OH_Rdb_CloseStore(storeTestRdbStore_);
1703 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, "rdb id is fail.");
1704
1705 valueObject->id = valueObjectID;
1706 valueBucket->id = valueBucketID;
1707 predicates->id = predicatesID;
1708 cursor->id = cursorID;
1709 storeTestRdbStore_->id = rdbID;
1710
1711 errCode = valueObject->destroy(valueObject);
1712 NAPI_ASSERT(env, errCode ==0, "valueObject id2 is fail.");
1713 errCode = valueBucket->destroy(valueBucket);
1714 NAPI_ASSERT(env, errCode == 0, "valueBucket id2 is fail.");
1715 errCode = predicates->destroy(predicates);
1716 NAPI_ASSERT(env, errCode == 0, "predicates id2 is fail.");
1717 errCode = cursor->destroy(cursor);
1718 NAPI_ASSERT(env, errCode == 0, "cursor id2 is fail.");
1719
1720 napi_value returnCode;
1721 napi_create_double(env, errCode, &returnCode);
1722 return returnCode;
1723 }
1724
1725 /**
1726 * @tc.name: SUB_DDM_RDB_3200
1727 * @tc.desc: napi test RDB store for dataBaseDir wrong
1728 * @tc.type: FUNC
1729 */
SUB_DDM_RDB_3200(napi_env env,napi_callback_info info)1730 static napi_value SUB_DDM_RDB_3200(napi_env env, napi_callback_info info) {
1731
1732 char RDB_TEST_PATH2[] = "/data";
1733 char RDB_STORE_NAME2[] = "rdb_store_test2.db";
1734
1735 OH_Rdb_Config config2_;
1736 config2_.dataBaseDir = RDB_TEST_PATH2;
1737 config2_.storeName = RDB_STORE_NAME2;
1738 config2_.bundleName = BUNDLE_NAME;
1739 config2_.moduleName = MODULE_NAME;
1740 config2_.securityLevel = OH_Rdb_SecurityLevel::S1;
1741 config2_.isEncrypt = false;
1742 config2_.selfSize = sizeof(OH_Rdb_Config);
1743
1744 mkdir(config2_.dataBaseDir, 0770);
1745
1746 int errCode = 0;
1747 storeTestRdbStore1_ = OH_Rdb_GetOrOpen(&config2_, &errCode);
1748 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_CREATE_FOLDER_FAIL , "OH_Rdb_GetOrOpen is fail.");
1749 errCode = 0;
1750
1751 OH_Rdb_CloseStore(storeTestRdbStore1_);
1752 OH_Rdb_DeleteStore(&config2_);
1753
1754 napi_value returnCode;
1755 napi_create_double(env, errCode, &returnCode);
1756 return returnCode;
1757 }
1758
1759 /**
1760 * @tc.name: SUB_DDM_RDB_3300
1761 * @tc.desc: napi test RDB store for dataBaseDir wrong
1762 * @tc.type: FUNC
1763 */
SUB_DDM_RDB_3300(napi_env env,napi_callback_info info)1764 static napi_value SUB_DDM_RDB_3300(napi_env env, napi_callback_info info) {
1765
1766 char RDB_TEST_PATH3[] = "";
1767 char RDB_STORE_NAME3[] = "rdb_store_test3.db";
1768
1769 OH_Rdb_Config config3_;
1770 config3_.dataBaseDir = RDB_TEST_PATH3;
1771 config3_.storeName = RDB_STORE_NAME3;
1772 config3_.bundleName = BUNDLE_NAME;
1773 config3_.moduleName = MODULE_NAME;
1774 config3_.securityLevel = OH_Rdb_SecurityLevel::S1;
1775 config3_.isEncrypt = false;
1776 config3_.selfSize = sizeof(OH_Rdb_Config);
1777
1778 mkdir(config3_.dataBaseDir, 0770);
1779
1780 int errCode = 0;
1781 storeTestRdbStore2_ = OH_Rdb_GetOrOpen(&config3_, &errCode);
1782 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_CREATE_FOLDER_FAIL , "OH_Rdb_GetOrOpen is fail.");
1783 errCode = 0;
1784
1785 OH_Rdb_CloseStore(storeTestRdbStore2_);
1786 OH_Rdb_DeleteStore(&config3_);
1787
1788 napi_value returnCode;
1789 napi_create_double(env, errCode, &returnCode);
1790 return returnCode;
1791 }
1792
1793 /**
1794 * @tc.name: SUB_DDM_RDB_3400
1795 * @tc.desc: napi test RDB store for CloudSync TIME_FIRST
1796 * @tc.type: FUNC
1797 */
SUB_DDM_RDB_3400(napi_env env,napi_callback_info info)1798 static napi_value SUB_DDM_RDB_3400(napi_env env, napi_callback_info info) {
1799 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr , "OH_Rdb_GetOrOpen is fail.");
1800 g_env = env;
1801 constexpr int TABLE_COUNT = 1;
1802 const char *table[TABLE_COUNT];
1803 table[0] = "store_test";
1804
1805 Rdb_ProgressObserver observer;
1806 void *context = nullptr;
1807 observer.context = &context;
1808 observer.callback = ProgressCallback;
1809 auto errCode = OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_TIME_FIRST,
1810 table, TABLE_COUNT, &observer);
1811 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_OK , "OH_Rdb_CloudSync TIME_FIRST is fail.");
1812 errCode = 0;
1813
1814 napi_value returnCode;
1815 napi_create_double(env, errCode, &returnCode);
1816 return returnCode;
1817 }
1818
1819 /**
1820 * @tc.name: SUB_DDM_RDB_3500
1821 * @tc.desc: napi test RDB store for CloudSync CLOUD_FIRST
1822 * @tc.type: FUNC
1823 */
SUB_DDM_RDB_3500(napi_env env,napi_callback_info info)1824 static napi_value SUB_DDM_RDB_3500(napi_env env, napi_callback_info info) {
1825 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr , "OH_Rdb_GetOrOpen is fail.");
1826 constexpr int TABLE_COUNT = 1;
1827 const char *table[TABLE_COUNT];
1828 table[0] = "store_test";
1829 Rdb_ProgressObserver observer;
1830 void *context = nullptr;
1831 observer.context = &context;
1832 observer.callback = ProgressCallback;
1833 int errCode = OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_CLOUD_FIRST,
1834 table, TABLE_COUNT, &observer);
1835 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_OK , "OH_Rdb_CloudSync is fail.");
1836 errCode = 0;
1837
1838 napi_value returnCode;
1839 napi_create_double(env, errCode, &returnCode);
1840 return returnCode;
1841 }
1842
1843 /**
1844 * @tc.name: SUB_DDM_RDB_3600
1845 * @tc.desc: napi test RDB store for CloudSync NATIVE_FIRST
1846 * @tc.type: FUNC
1847 */
SUB_DDM_RDB_3600(napi_env env,napi_callback_info info)1848 static napi_value SUB_DDM_RDB_3600(napi_env env, napi_callback_info info) {
1849 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr , "OH_Rdb_GetOrOpen is fail.");
1850 constexpr int TABLE_COUNT = 1;
1851 const char *table[TABLE_COUNT];
1852 table[0] = "store_test";
1853 Rdb_ProgressObserver observer;
1854 void *context = nullptr;
1855 observer.context = &context;
1856 observer.callback = ProgressCallback;
1857 int errCode = OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_NATIVE_FIRST,
1858 table, TABLE_COUNT, &observer);
1859 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_OK , "OH_Rdb_CloudSync is fail.");
1860 errCode = 0;
1861
1862 napi_value returnCode;
1863 napi_create_double(env, errCode, &returnCode);
1864 return returnCode;
1865 }
1866
1867 /**
1868 * @tc.name: SUB_DDM_RDB_3700
1869 * @tc.desc: napi test RDB store for CloudSync err
1870 * @tc.type: FUNC
1871 */
SUB_DDM_RDB_3700(napi_env env,napi_callback_info info)1872 static napi_value SUB_DDM_RDB_3700(napi_env env, napi_callback_info info) {
1873 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr , "OH_Rdb_GetOrOpen is fail.");
1874 constexpr int TABLE_COUNT = 1;
1875 const char *table[TABLE_COUNT];
1876 table[0] = "store_test";
1877
1878 int errCode = OH_Rdb_CloudSync(storeTestRdbStore_, Rdb_SyncMode::RDB_SYNC_MODE_NATIVE_FIRST, table, TABLE_COUNT, nullptr);
1879 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS , "OH_Rdb_CloudSync is fail.");
1880 errCode = 0;
1881
1882 napi_value returnCode;
1883 napi_create_double(env, errCode, &returnCode);
1884 return returnCode;
1885 }
1886 /**
1887 * @tc.name: SUB_DDM_RDB_3800
1888 * @tc.desc: napi test RDB store for CloudSync err
1889 * @tc.type: FUNC
1890 */
SUB_DDM_RDB_3800(napi_env env,napi_callback_info info)1891 static napi_value SUB_DDM_RDB_3800(napi_env env, napi_callback_info info) {
1892 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr , "OH_Rdb_GetOrOpen is fail.");
1893 constexpr int TABLE_COUNT = 1;
1894 const char *table[TABLE_COUNT];
1895 table[0] = "store_test";
1896 Rdb_ProgressObserver observer;
1897 void *context = nullptr;
1898 observer.context = &context;
1899 observer.callback = ProgressCallback;
1900 int errCode = OH_Rdb_CloudSync(nullptr, Rdb_SyncMode::RDB_SYNC_MODE_CLOUD_FIRST, table, TABLE_COUNT, &observer);
1901 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS , "OH_Rdb_CloudSync is fail.");
1902 errCode = 0;
1903 napi_value returnCode;
1904 napi_create_double(env, errCode, &returnCode);
1905 return returnCode;
1906 }
1907
1908 /**
1909 * @tc.name: SUB_DDM_RDB_3900
1910 * @tc.desc: napi test RDB store for SetDistributedTables RdbStore err
1911 * @tc.type: FUNC
1912 */
SUB_DDM_RDB_3900(napi_env env,napi_callback_info info)1913 static napi_value SUB_DDM_RDB_3900(napi_env env, napi_callback_info info) {
1914 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr , "OH_Rdb_GetOrOpen is fail.");
1915 Rdb_DistributedConfig config{ .version = 0, .isAutoSync = true };
1916 constexpr int TABLE_COUNT = 1;
1917 const char *table[TABLE_COUNT];
1918 table[0] = "store_test";
1919 config.version = DISTRIBUTED_CONFIG_VERSION;
1920 int errCode = OH_Rdb_SetDistributedTables(nullptr, table, TABLE_COUNT, Rdb_DistributedType::RDB_DISTRIBUTED_CLOUD, &config);
1921 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS , "OH_Rdb_SetDistributedTables 2 is fail.");
1922 errCode = 0;
1923 napi_value returnCode;
1924 napi_create_double(env, errCode, &returnCode);
1925 return returnCode;
1926 }
1927 /**
1928 * @tc.name: SUB_DDM_RDB_4000
1929 * @tc.desc: napi test RDB store for SetDistributedTables err
1930 * @tc.type: FUNC
1931 */
SUB_DDM_RDB_4000(napi_env env,napi_callback_info info)1932 static napi_value SUB_DDM_RDB_4000(napi_env env, napi_callback_info info) {
1933 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr , "OH_Rdb_GetOrOpen is fail.");
1934 Rdb_DistributedConfig config{ .version = 0, .isAutoSync = true };
1935 constexpr int TABLE_COUNT = 1;
1936 const char *table[TABLE_COUNT];
1937 table[0] = "store_test";
1938 config.version = DISTRIBUTED_CONFIG_VERSION;
1939 int errCode = OH_Rdb_SetDistributedTables(NULL, table, TABLE_COUNT, Rdb_DistributedType::RDB_DISTRIBUTED_CLOUD, &config);
1940 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS , "OH_Rdb_SetDistributedTables 2 is fail.");
1941 errCode = 0;
1942
1943 napi_value returnCode;
1944 napi_create_double(env, errCode, &returnCode);
1945 return returnCode;
1946 }
1947 /**
1948 * @tc.name: SUB_DDM_RDB_4100
1949 * @tc.desc: napi test RDB store for OH_Rdb_FindModifyTime
1950 * @tc.type: FUNC
1951 */
SUB_DDM_RDB_4100(napi_env env,napi_callback_info info)1952 static napi_value SUB_DDM_RDB_4100(napi_env env, napi_callback_info info)
1953 {
1954 char createLogTableSql[] = "CREATE TABLE if not exists naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
1955 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
1956 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);";
1957 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createLogTableSql);
1958 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_OK , "OH_Rdb_Execute 1 is fail.");
1959
1960 OH_VBucket *bucket = OH_Rdb_CreateValuesBucket();
1961 bucket->putInt64(bucket, "data_key", 1);
1962 bucket->putInt64(bucket, "timestamp", 1000000000);
1963 errCode = OH_Rdb_Insert(storeTestRdbStore_, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", bucket);
1964 NAPI_ASSERT(env, errCode == 1 , "OH_Rdb_Insert 1 is fail.");
1965
1966 OH_VObject *values = OH_Rdb_CreateValueObject();
1967 int64_t keys[] = { 1 };
1968 values->putInt64(values, keys, 1);
1969
1970 OH_Cursor *cursor;
1971 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdbstoreimpltest_integer", "ROWID", values);
1972 int rowCount;
1973 errCode = cursor->getRowCount(cursor, &rowCount);
1974 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_OK , "getRowCount is fail.");
1975 NAPI_ASSERT(env, rowCount == 1 , "OH_Rdb_Execute 1 is fail.");
1976 cursor->goToNextRow(cursor);
1977 int64_t key = 0;
1978 cursor->getInt64(cursor, 0, &key);
1979 NAPI_ASSERT(env, key == 1 , "getInt64 1 is fail.");
1980 int64_t time = 0;
1981 cursor->getInt64(cursor, 1, &time);
1982 NAPI_ASSERT(env, time == 100000 , "getInt64 1 is fail.");
1983
1984 cursor->destroy(cursor);
1985 char dropLogTableSql[] = "DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log";
1986 errCode = OH_Rdb_Execute(storeTestRdbStore_, dropLogTableSql);
1987 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_OK , "OH_Rdb_Execute is fail.");
1988 errCode = 0;
1989
1990 napi_value returnCode;
1991 napi_create_double(env, errCode, &returnCode);
1992 return returnCode;
1993 }
1994
1995
1996 /**
1997 * @tc.name: SUB_DDM_RDB_4200
1998 * @tc.desc: napi test RDB store for OH_Rdb_FindModifyTime, tablename columnName, keys is empty,
1999 * and resultSet is null or empty
2000 * @tc.type: FUNC
2001 */
SUB_DDM_RDB_4200(napi_env env,napi_callback_info info)2002 static napi_value SUB_DDM_RDB_4200(napi_env env, napi_callback_info info)
2003 {
2004 char createLogTableSql[] = "CREATE TABLE if not exists naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
2005 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
2006 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);";
2007 int errCode = OH_Rdb_Execute(storeTestRdbStore_, createLogTableSql);
2008 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_OK , "OH_Rdb_Execute 1 is fail.");
2009
2010 OH_VBucket *bucket = OH_Rdb_CreateValuesBucket();
2011 bucket->putInt64(bucket, "data_key", 1);
2012 bucket->putInt64(bucket, "timestamp", 1000000000);
2013 errCode = OH_Rdb_Insert(storeTestRdbStore_, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", bucket);
2014 NAPI_ASSERT(env, errCode == 1 , "OH_Rdb_Insert 1 is fail.");
2015
2016 OH_VObject *values = OH_Rdb_CreateValueObject();
2017 int64_t keys[] = { 1 };
2018 values->putInt64(values, keys, 1);
2019
2020 // table name is ""
2021 OH_Cursor *cursor;
2022 cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "", "data_key", values);
2023 int rowCount = 0;
2024 errCode = cursor->getRowCount(cursor, &rowCount);
2025 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_E_INVALID_ARGS , "getRowCount 1 is fail.");
2026
2027 cursor->destroy(cursor);
2028 char dropLogTableSql[] = "DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log";
2029 errCode = OH_Rdb_Execute(storeTestRdbStore_, dropLogTableSql);
2030 NAPI_ASSERT(env, errCode == OH_Rdb_ErrCode::RDB_OK , "OH_Rdb_Execute 1 is fail.");
2031 errCode = 0;
2032
2033 napi_value returnCode;
2034 napi_create_double(env, errCode, &returnCode);
2035 return returnCode;
2036 }
2037
2038
2039 /**
2040 * @tc.name: SUB_DDM_RDB_4300
2041 * @tc.desc: napi test RDB store for Rdb_ChangeInfo
2042 * @tc.type: FUNC
2043 */
SUB_DDM_RDB_4300(napi_env env,napi_callback_info info)2044 static napi_value SUB_DDM_RDB_4300(napi_env env, napi_callback_info info)
2045 {
2046 Rdb_KeyInfo::Rdb_KeyData keydata_;
2047 keydata_.integer = 1;
2048 keydata_.real = 1.0;
2049 keydata_.text = "rdbtest";
2050
2051 Rdb_KeyInfo keyinfo_1;
2052 keyinfo_1.count = 1;
2053 keyinfo_1.type = 1;
2054 keyinfo_1.data = &keydata_;
2055
2056 Rdb_KeyInfo keyinfo_2;
2057 keyinfo_2.count = 1;
2058 keyinfo_2.type = 1;
2059 keyinfo_2.data = &keydata_;
2060
2061 Rdb_KeyInfo keyinfo_3;
2062 keyinfo_3.count = 1;
2063 keyinfo_3.type = 1;
2064 keyinfo_3.data = &keydata_;
2065
2066 Rdb_ChangeInfo changeinfo_;
2067 changeinfo_.version = 1;
2068 changeinfo_.tableName = "tablename";
2069 changeinfo_.ChangeType = 1;
2070 changeinfo_.inserted = keyinfo_1;
2071 changeinfo_.updated = keyinfo_2;
2072 changeinfo_.deleted = keyinfo_3;
2073
2074 NAPI_ASSERT(env, Rdb_ChangeType::RDB_DATA_CHANGE == 0 , "RDB_DATA_CHANGE 1 is fail.");
2075 NAPI_ASSERT(env, Rdb_ChangeType::RDB_ASSET_CHANGE == 1 , "RDB_ASSET_CHANGE 1 is fail.");
2076
2077 NAPI_ASSERT(env, keyinfo_1.count == 1 , "count 1 is fail.");
2078 NAPI_ASSERT(env, keyinfo_1.type == 1 , "type 1 is fail.");
2079 NAPI_ASSERT(env, keyinfo_1.data == &keydata_ , "keydata_ 1 is fail.");
2080
2081 NAPI_ASSERT(env, changeinfo_.version == 1 , "version 1 is fail.");
2082 NAPI_ASSERT(env, strncmp(changeinfo_.tableName, "tablename", 10) == 0, "tablename is fail.");
2083 NAPI_ASSERT(env, changeinfo_.ChangeType == 1 , "ChangeType 1 is fail.");
2084 NAPI_ASSERT(env, changeinfo_.inserted.count == 1 , "keyinfo_1 1 is fail.");
2085 NAPI_ASSERT(env, changeinfo_.updated.count == 1 , "keyinfo_2 1 is fail.");
2086 NAPI_ASSERT(env, changeinfo_.deleted.count == 1 , "keyinfo_3 1 is fail.");
2087 int errCode = 0;
2088 napi_value returnCode;
2089 napi_create_double(env, errCode, &returnCode);
2090 return returnCode;
2091
2092 }
2093 /**
2094 * @tc.name: SUB_DDM_RDB_4400
2095 * @tc.desc: napi test RDB store for Rdb_TableDetails
2096 * @tc.type: FUNC
2097 */
SUB_DDM_RDB_4400(napi_env env,napi_callback_info info)2098 static napi_value SUB_DDM_RDB_4400(napi_env env, napi_callback_info info)
2099 {
2100 Rdb_Statistic statistic_;
2101 statistic_.total = 1;
2102 statistic_.successful = 1;
2103 statistic_.failed = 1;
2104 statistic_.remained = 1;
2105
2106 Rdb_Statistic statistic_2;
2107 statistic_2.total = 1;
2108 statistic_2.successful = 1;
2109 statistic_2.failed = 1;
2110 statistic_2.remained = 1;
2111
2112 Rdb_TableDetails tabledetails_;
2113 tabledetails_.table = "tablename";
2114 tabledetails_.upload = statistic_;
2115 tabledetails_.download = statistic_2;
2116
2117 NAPI_ASSERT(env, Rdb_SubscribeType::RDB_SUBSCRIBE_TYPE_CLOUD == 0 , "RDB_SUBSCRIBE_TYPE_CLOUD 1 is fail.");
2118 NAPI_ASSERT(env, Rdb_SubscribeType::RDB_SUBSCRIBE_TYPE_CLOUD_DETAILS == 1 , "RDB_SUBSCRIBE_TYPE_CLOUD_DETAILS 1 is fail.");
2119
2120 NAPI_ASSERT(env, statistic_.total == 1 , "total 1 is fail.");
2121 NAPI_ASSERT(env, statistic_.successful == 1 , "successful 1 is fail.");
2122 NAPI_ASSERT(env, statistic_.failed == 1 , "failed 1 is fail.");
2123 NAPI_ASSERT(env, statistic_.remained == 1 , "remained 1 is fail.");
2124 NAPI_ASSERT(env, strncmp(tabledetails_.table, "tablename", 10) == 0, "tablename is fail.");
2125 NAPI_ASSERT(env, tabledetails_.upload.total == 1 , "tabledetails_ upload 1 is fail.");
2126 NAPI_ASSERT(env, tabledetails_.download.total == 1 , "tabledetails_ download 1 is fail.");
2127 int errCode = 0;
2128 napi_value returnCode;
2129 napi_create_double(env, errCode, &returnCode);
2130 return returnCode;
2131 }
2132 /**
2133 * @tc.name: SUB_DDM_RDB_4500
2134 * @tc.desc: napi test RDB store for Rdb_ProgressDetails
2135 * @tc.type: FUNC
2136 */
SUB_DDM_RDB_4500(napi_env env,napi_callback_info info)2137 static napi_value SUB_DDM_RDB_4500(napi_env env, napi_callback_info info)
2138 {
2139 Rdb_ProgressDetails progressdetails_;
2140 progressdetails_.version = 1;
2141 progressdetails_.schedule = 1;
2142 progressdetails_.code = 1;
2143 progressdetails_.tableLength = 10;
2144 NAPI_ASSERT(env, progressdetails_.version == 1 , "progressdetails_.version 1 is fail.");
2145 NAPI_ASSERT(env, progressdetails_.schedule == 1 , "progressdetails_.schedule 1 is fail.");
2146 NAPI_ASSERT(env, progressdetails_.code == 1 , "progressdetails_.code 1 is fail.");
2147 NAPI_ASSERT(env, progressdetails_.tableLength == 10 , "progressdetails_.tableLength 1 is fail.");
2148
2149 NAPI_ASSERT(env, Rdb_Progress ::RDB_SYNC_BEGIN == 0 , "RDB_SYNC_BEGIN 1 is fail.");
2150 NAPI_ASSERT(env, Rdb_Progress ::RDB_SYNC_IN_PROGRESS == 1 , "RDB_SYNC_IN_PROGRESS 1 is fail.");
2151 NAPI_ASSERT(env, Rdb_Progress ::RDB_SYNC_FINISH == 2 , "RDB_SYNC_FINISH 1 is fail.");
2152
2153 NAPI_ASSERT(env, Rdb_ProgressCode::RDB_SUCCESS == 0 , "Rdb_ProgressCode RDB_SUCCESS 1 is fail.");
2154 NAPI_ASSERT(env, Rdb_ProgressCode::RDB_UNKNOWN_ERROR == 1 , "RDB_UNKNOWN_ERROR 1 is fail.");
2155 NAPI_ASSERT(env, Rdb_ProgressCode::RDB_NETWORK_ERROR == 2 , "RDB_NETWORK_ERROR 1 is fail.");
2156 NAPI_ASSERT(env, Rdb_ProgressCode::RDB_CLOUD_DISABLED == 3 , "RDB_CLOUD_DISABLED 1 is fail.");
2157 NAPI_ASSERT(env, Rdb_ProgressCode::RDB_LOCKED_BY_OTHERS == 4 , "RDB_LOCKED_BY_OTHERS 1 is fail.");
2158 NAPI_ASSERT(env, Rdb_ProgressCode::RDB_RECORD_LIMIT_EXCEEDED == 5 , "RDB_RECORD_LIMIT_EXCEEDED 1 is fail.");
2159 NAPI_ASSERT(env, Rdb_ProgressCode::RDB_NO_SPACE_FOR_ASSET == 6 , "RDB_NO_SPACE_FOR_ASSET 1 is fail.");
2160 int errCode = 0;
2161 napi_value returnCode;
2162 napi_create_double(env, errCode, &returnCode);
2163 return returnCode;
2164 }
2165
2166
2167 /**
2168 * @tc.name: SUB_DDM_RDB_4600
2169 * @tc.desc: napi test RDB store for Query with wrong table or table is NULL.
2170 * @tc.type: FUNC
2171 */
SUB_DDM_RDB_4600(napi_env env,napi_callback_info info)2172 static napi_value SUB_DDM_RDB_4600(napi_env env, napi_callback_info info)
2173 {
2174 int errCode = -1;
2175 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr, "store is nullptr.");
2176 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD, &briefObs);
2177 NAPI_ASSERT(env, errCode == RDB_OK, "sub1 failed.");
2178
2179 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD, &briefObs);
2180 NAPI_ASSERT(env, errCode == RDB_OK, "sub2 failed.");
2181
2182 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD, nullptr);
2183 NAPI_ASSERT(env, errCode == RDB_E_INVALID_ARGS, "sub3 failed.");
2184
2185 errCode = OH_Rdb_Subscribe(nullptr, RDB_SUBSCRIBE_TYPE_CLOUD, &briefObs);
2186 NAPI_ASSERT(env, errCode == RDB_E_INVALID_ARGS, "sub4 failed.");
2187
2188 napi_value returnCode;
2189 if (errCode == RDB_E_INVALID_ARGS) {
2190 errCode = RDB_OK;
2191 }
2192 napi_create_double(env, errCode, &returnCode);
2193 return returnCode;
2194 }
2195
2196
2197 /**
2198 * @tc.name: SUB_DDM_RDB_4700
2199 * @tc.desc: napi test RDB store for Query with wrong table or table is NULL.
2200 * @tc.type: FUNC
2201 */
SUB_DDM_RDB_4700(napi_env env,napi_callback_info info)2202 static napi_value SUB_DDM_RDB_4700(napi_env env, napi_callback_info info)
2203 {
2204 int errCode = -1;
2205 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr, "store is nullptr.");
2206
2207 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD_DETAILS, &detailObs);
2208 NAPI_ASSERT(env, errCode == RDB_OK, "sub1 failed.");
2209
2210 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD_DETAILS, &detailObs);
2211 NAPI_ASSERT(env, errCode == RDB_OK, "sub2 failed.");
2212
2213 errCode = OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD_DETAILS, nullptr);
2214 NAPI_ASSERT(env, errCode == RDB_E_INVALID_ARGS, "sub3 failed.");
2215
2216 errCode = OH_Rdb_Subscribe(nullptr, RDB_SUBSCRIBE_TYPE_CLOUD_DETAILS, &detailObs);
2217 NAPI_ASSERT(env, errCode == RDB_E_INVALID_ARGS, "sub4 failed.");
2218
2219 napi_value returnCode;
2220 if (errCode == RDB_E_INVALID_ARGS) {
2221 errCode = RDB_OK;
2222 }
2223 napi_create_double(env, errCode, &returnCode);
2224 return returnCode;
2225 }
2226
2227
2228 /**
2229 * @tc.name: SUB_DDM_RDB_4800
2230 * @tc.desc: napi test RDB store for Query with wrong table or table is NULL.
2231 * @tc.type: FUNC
2232 */
SUB_DDM_RDB_4800(napi_env env,napi_callback_info info)2233 static napi_value SUB_DDM_RDB_4800(napi_env env, napi_callback_info info)
2234 {
2235 int errCode = -1;
2236 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr, "store is nullptr.");
2237
2238 errCode = OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD, &briefObs);
2239 NAPI_ASSERT(env, errCode == RDB_OK, "unsub1 failed.");
2240
2241 errCode = OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD, nullptr);
2242 NAPI_ASSERT(env, errCode == RDB_OK, "unsub2 failed.");
2243
2244 errCode = OH_Rdb_Unsubscribe(nullptr, RDB_SUBSCRIBE_TYPE_CLOUD, &briefObs);
2245 NAPI_ASSERT(env, errCode == RDB_E_INVALID_ARGS, "unsub3 failed.");
2246
2247 napi_value returnCode;
2248 if (errCode == RDB_E_INVALID_ARGS) {
2249 errCode = RDB_OK;
2250 }
2251 napi_create_double(env, errCode, &returnCode);
2252 return returnCode;
2253 }
2254
2255 /**
2256 * @tc.name: SUB_DDM_RDB_4900
2257 * @tc.desc: napi test RDB store for Query with wrong table or table is NULL.
2258 * @tc.type: FUNC
2259 */
SUB_DDM_RDB_4900(napi_env env,napi_callback_info info)2260 static napi_value SUB_DDM_RDB_4900(napi_env env, napi_callback_info info)
2261 {
2262 int errCode = -1;
2263 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr, "store is nullptr.");
2264
2265 errCode = OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD_DETAILS, &detailObs);
2266 NAPI_ASSERT(env, errCode == RDB_OK, "unsub1 failed.");
2267
2268 errCode = OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_CLOUD_DETAILS, nullptr);
2269 NAPI_ASSERT(env, errCode == RDB_OK, "unsub2 failed.");
2270
2271 errCode = OH_Rdb_Unsubscribe(nullptr, RDB_SUBSCRIBE_TYPE_CLOUD_DETAILS, &detailObs);
2272 NAPI_ASSERT(env, errCode == RDB_E_INVALID_ARGS, "unsub3 failed.");
2273
2274 napi_value returnCode;
2275 if (errCode == RDB_E_INVALID_ARGS) {
2276 errCode = RDB_OK;
2277 }
2278 napi_create_double(env, errCode, &returnCode);
2279 return returnCode;
2280 }
2281
2282
2283 /**
2284 * @tc.name: SUB_DDM_RDB_5000
2285 * @tc.desc: napi test RDB store for OH_Rdb_UnsubscribeAutoSyncProgress test.
2286 * @tc.type: FUNC
2287 */
SUB_DDM_RDB_5000(napi_env env,napi_callback_info info)2288 static napi_value SUB_DDM_RDB_5000(napi_env env, napi_callback_info info)
2289 {
2290 int errCode = -1;
2291 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr, "store is nullptr.");
2292 errCode = OH_Rdb_UnsubscribeAutoSyncProgress(storeTestRdbStore_, &observer);
2293
2294 NAPI_ASSERT(env, errCode == RDB_OK, "unsub1 failed.");
2295 errCode = OH_Rdb_UnsubscribeAutoSyncProgress(storeTestRdbStore_, &observer);
2296
2297 NAPI_ASSERT(env, errCode == RDB_OK, "unsub2 failed.");
2298 errCode = OH_Rdb_UnsubscribeAutoSyncProgress(storeTestRdbStore_, nullptr);
2299
2300 NAPI_ASSERT(env, errCode == RDB_OK, "unsub3 failed.");
2301 errCode = OH_Rdb_UnsubscribeAutoSyncProgress(nullptr, &observer);
2302
2303 NAPI_ASSERT(env, errCode == RDB_E_INVALID_ARGS, "unsub4 failed.");
2304 napi_value returnCode;
2305 if (errCode == RDB_E_INVALID_ARGS) {
2306 errCode = RDB_OK;
2307 }
2308 napi_create_double(env, errCode, &returnCode);
2309 return returnCode;
2310 }
2311
2312 /**
2313 * @tc.name: SUB_DDM_RDB_5100
2314 * @tc.desc: napi test RDB store for OH_Rdb_subscribeAutoSyncProgress test.
2315 * @tc.type: FUNC
2316 */
2317
SUB_DDM_RDB_5100(napi_env env,napi_callback_info info)2318 static napi_value SUB_DDM_RDB_5100(napi_env env, napi_callback_info info)
2319 {
2320 int errCode = -1;
2321 NAPI_ASSERT(env, storeTestRdbStore_ != nullptr, "store is nullptr.");
2322 errCode = OH_Rdb_SubscribeAutoSyncProgress(storeTestRdbStore_, &observer);
2323 NAPI_ASSERT(env, errCode == RDB_OK, "sub1 failed.");
2324
2325 errCode = OH_Rdb_SubscribeAutoSyncProgress(storeTestRdbStore_, &observer);
2326 NAPI_ASSERT(env, errCode == RDB_OK, "sub2 failed.");
2327
2328 errCode = OH_Rdb_SubscribeAutoSyncProgress(storeTestRdbStore_, nullptr);
2329 NAPI_ASSERT(env, errCode == RDB_E_INVALID_ARGS, "sub3 failed.");
2330
2331 errCode = OH_Rdb_SubscribeAutoSyncProgress(nullptr, &observer);
2332 NAPI_ASSERT(env, errCode == RDB_E_INVALID_ARGS, "sub4 failed.");
2333
2334 napi_value returnCode;
2335 if (errCode == RDB_E_INVALID_ARGS) {
2336 errCode = RDB_OK;
2337 }
2338 napi_create_double(env, errCode, &returnCode);
2339 return returnCode;
2340 }
2341
2342 EXTERN_C_START
Init(napi_env env,napi_value exports)2343 static napi_value Init(napi_env env, napi_value exports) {
2344 napi_property_descriptor desc[] = {
2345 {"RdbFilePath", nullptr, RdbFilePath, nullptr, nullptr, nullptr, napi_default, nullptr},
2346 {"RdbstoreSetUpTestCase", nullptr, RdbstoreSetUpTestCase, nullptr, nullptr, nullptr, napi_default, nullptr},
2347 {"RdbstoreTearDownTestCase", nullptr, RdbstoreTearDownTestCase, nullptr, nullptr, nullptr, napi_default, nullptr},
2348 {"SUB_DDM_RDB_0100", nullptr, SUB_DDM_RDB_0100, nullptr, nullptr, nullptr, napi_default, nullptr},
2349 {"SUB_DDM_RDB_0200", nullptr, SUB_DDM_RDB_0200, nullptr, nullptr, nullptr, napi_default, nullptr},
2350 {"SUB_DDM_RDB_0300", nullptr, SUB_DDM_RDB_0300, nullptr, nullptr, nullptr, napi_default, nullptr},
2351 {"SUB_DDM_RDB_0400", nullptr, SUB_DDM_RDB_0400, nullptr, nullptr, nullptr, napi_default, nullptr},
2352 {"SUB_DDM_RDB_0500", nullptr, SUB_DDM_RDB_0500, nullptr, nullptr, nullptr, napi_default, nullptr},
2353 {"SUB_DDM_RDB_0600", nullptr, SUB_DDM_RDB_0600, nullptr, nullptr, nullptr, napi_default, nullptr},
2354 {"SUB_DDM_RDB_0700", nullptr, SUB_DDM_RDB_0700, nullptr, nullptr, nullptr, napi_default, nullptr},
2355 {"SUB_DDM_RDB_0800", nullptr, SUB_DDM_RDB_0800, nullptr, nullptr, nullptr, napi_default, nullptr},
2356 {"SUB_DDM_RDB_0900", nullptr, SUB_DDM_RDB_0900, nullptr, nullptr, nullptr, napi_default, nullptr},
2357 {"SUB_DDM_RDB_1000", nullptr, SUB_DDM_RDB_1000, nullptr, nullptr, nullptr, napi_default, nullptr},
2358 {"SUB_DDM_RDB_1100", nullptr, SUB_DDM_RDB_1100, nullptr, nullptr, nullptr, napi_default, nullptr},
2359 {"SUB_DDM_RDB_1200", nullptr, SUB_DDM_RDB_1200, nullptr, nullptr, nullptr, napi_default, nullptr},
2360 {"SUB_DDM_RDB_1300", nullptr, SUB_DDM_RDB_1300, nullptr, nullptr, nullptr, napi_default, nullptr},
2361 {"SUB_DDM_RDB_1400", nullptr, SUB_DDM_RDB_1400, nullptr, nullptr, nullptr, napi_default, nullptr},
2362 {"SUB_DDM_RDB_1500", nullptr, SUB_DDM_RDB_1500, nullptr, nullptr, nullptr, napi_default, nullptr},
2363 {"SUB_DDM_RDB_1600", nullptr, SUB_DDM_RDB_1600, nullptr, nullptr, nullptr, napi_default, nullptr},
2364 {"SUB_DDM_RDB_1700", nullptr, SUB_DDM_RDB_1700, nullptr, nullptr, nullptr, napi_default, nullptr},
2365 {"SUB_DDM_RDB_1800", nullptr, SUB_DDM_RDB_1800, nullptr, nullptr, nullptr, napi_default, nullptr},
2366 {"SUB_DDM_RDB_1900", nullptr, SUB_DDM_RDB_1900, nullptr, nullptr, nullptr, napi_default, nullptr},
2367 {"SUB_DDM_RDB_2000", nullptr, SUB_DDM_RDB_2000, nullptr, nullptr, nullptr, napi_default, nullptr},
2368 {"SUB_DDM_RDB_2100", nullptr, SUB_DDM_RDB_2100, nullptr, nullptr, nullptr, napi_default, nullptr},
2369 {"SUB_DDM_RDB_2200", nullptr, SUB_DDM_RDB_2200, nullptr, nullptr, nullptr, napi_default, nullptr},
2370 {"SUB_DDM_RDB_2300", nullptr, SUB_DDM_RDB_2300, nullptr, nullptr, nullptr, napi_default, nullptr},
2371 {"SUB_DDM_RDB_2400", nullptr, SUB_DDM_RDB_2400, nullptr, nullptr, nullptr, napi_default, nullptr},
2372 {"SUB_DDM_RDB_2500", nullptr, SUB_DDM_RDB_2500, nullptr, nullptr, nullptr, napi_default, nullptr},
2373 {"SUB_DDM_RDB_2600", nullptr, SUB_DDM_RDB_2600, nullptr, nullptr, nullptr, napi_default, nullptr},
2374 {"SUB_DDM_RDB_2700", nullptr, SUB_DDM_RDB_2700, nullptr, nullptr, nullptr, napi_default, nullptr},
2375 {"SUB_DDM_RDB_2800", nullptr, SUB_DDM_RDB_2800, nullptr, nullptr, nullptr, napi_default, nullptr},
2376 {"SUB_DDM_RDB_2900", nullptr, SUB_DDM_RDB_2900, nullptr, nullptr, nullptr, napi_default, nullptr},
2377 {"SUB_DDM_RDB_3000", nullptr, SUB_DDM_RDB_3000, nullptr, nullptr, nullptr, napi_default, nullptr},
2378 {"SUB_DDM_RDB_3100", nullptr, SUB_DDM_RDB_3100, nullptr, nullptr, nullptr, napi_default, nullptr},
2379 {"SUB_DDM_RDB_3200", nullptr, SUB_DDM_RDB_3200, nullptr, nullptr, nullptr, napi_default, nullptr},
2380 {"SUB_DDM_RDB_3300", nullptr, SUB_DDM_RDB_3300, nullptr, nullptr, nullptr, napi_default, nullptr},
2381 {"SUB_DDM_RDB_3400", nullptr, SUB_DDM_RDB_3400, nullptr, nullptr, nullptr, napi_default, nullptr},
2382 {"SUB_DDM_RDB_3500", nullptr, SUB_DDM_RDB_3500, nullptr, nullptr, nullptr, napi_default, nullptr},
2383 {"SUB_DDM_RDB_3600", nullptr, SUB_DDM_RDB_3600, nullptr, nullptr, nullptr, napi_default, nullptr},
2384 {"SUB_DDM_RDB_3700", nullptr, SUB_DDM_RDB_3700, nullptr, nullptr, nullptr, napi_default, nullptr},
2385 {"SUB_DDM_RDB_3800", nullptr, SUB_DDM_RDB_3800, nullptr, nullptr, nullptr, napi_default, nullptr},
2386 {"SUB_DDM_RDB_3900", nullptr, SUB_DDM_RDB_3900, nullptr, nullptr, nullptr, napi_default, nullptr},
2387 {"SUB_DDM_RDB_4000", nullptr, SUB_DDM_RDB_4000, nullptr, nullptr, nullptr, napi_default, nullptr},
2388 {"SUB_DDM_RDB_4100", nullptr, SUB_DDM_RDB_4100, nullptr, nullptr, nullptr, napi_default, nullptr},
2389 {"SUB_DDM_RDB_4200", nullptr, SUB_DDM_RDB_4200, nullptr, nullptr, nullptr, napi_default, nullptr},
2390 {"SUB_DDM_RDB_4300", nullptr, SUB_DDM_RDB_4300, nullptr, nullptr, nullptr, napi_default, nullptr},
2391 {"SUB_DDM_RDB_4400", nullptr, SUB_DDM_RDB_4400, nullptr, nullptr, nullptr, napi_default, nullptr},
2392 {"SUB_DDM_RDB_4500", nullptr, SUB_DDM_RDB_4500, nullptr, nullptr, nullptr, napi_default, nullptr},
2393 {"SUB_DDM_RDB_4600", nullptr, SUB_DDM_RDB_4600, nullptr, nullptr, nullptr, napi_default, nullptr},
2394 {"SUB_DDM_RDB_4700", nullptr, SUB_DDM_RDB_4700, nullptr, nullptr, nullptr, napi_default, nullptr},
2395 {"SUB_DDM_RDB_4800", nullptr, SUB_DDM_RDB_4800, nullptr, nullptr, nullptr, napi_default, nullptr},
2396 {"SUB_DDM_RDB_4900", nullptr, SUB_DDM_RDB_4900, nullptr, nullptr, nullptr, napi_default, nullptr},
2397 {"SUB_DDM_RDB_5000", nullptr, SUB_DDM_RDB_5000, nullptr, nullptr, nullptr, napi_default, nullptr},
2398 {"SUB_DDM_RDB_5100", nullptr, SUB_DDM_RDB_5100, nullptr, nullptr, nullptr, napi_default, nullptr}
2399
2400 };
2401
2402
2403 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
2404 return exports;
2405 }
2406 EXTERN_C_END
2407
2408
2409
2410 static napi_module demoModule = {
2411 .nm_version = 1,
2412 .nm_flags = 0,
2413 .nm_filename = nullptr,
2414 .nm_register_func = Init,
2415 .nm_modname = "rdbstore",
2416 .nm_priv = ((void *)0),
2417 .reserved = {0},
2418 };
2419
RegisterEntryModule(void)2420 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) {
2421 napi_module_register(&demoModule);
2422 }
2423