1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <sys/stat.h>
18 #include <sys/types.h>
19
20 #include <string>
21
22 #include "common.h"
23 #include "data_asset.h"
24 #include "relational_store.h"
25 #include "relational_store_error_code.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::NativeRdb;
29
30 class RdbNativeCursorTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
InitRdbConfig()36 static void InitRdbConfig()
37 {
38 config_.dataBaseDir = RDB_TEST_PATH;
39 config_.storeName = "rdb_cursor_test.db";
40 config_.bundleName = "com.ohos.example.distributedndk";
41 config_.moduleName = "";
42 config_.securityLevel = OH_Rdb_SecurityLevel::S1;
43 config_.isEncrypt = false;
44 config_.area = Rdb_SecurityArea::RDB_SECURITY_AREA_EL1;
45 config_.selfSize = sizeof(OH_Rdb_Config);
46 }
47 static void CreateAssetTable();
48 static void SetAsset(Data_Asset *asset, int index);
49 static OH_Rdb_Config config_;
50 };
51
52 OH_Rdb_Store *cursorTestRdbStore_;
53 OH_Rdb_Config RdbNativeCursorTest::config_ = { 0 };
SetUpTestCase(void)54 void RdbNativeCursorTest::SetUpTestCase(void)
55 {
56 InitRdbConfig();
57 mkdir(config_.dataBaseDir, 0770);
58 int errCode = 0;
59 char table[] = "test";
60 cursorTestRdbStore_ = OH_Rdb_GetOrOpen(&config_, &errCode);
61 EXPECT_NE(cursorTestRdbStore_, NULL);
62 char createTableSql[] = "CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
63 "data3 FLOAT, data4 BLOB, data5 TEXT);";
64 errCode = OH_Rdb_Execute(cursorTestRdbStore_, createTableSql);
65
66 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
67 valueBucket->putInt64(valueBucket, "id", 1);
68 valueBucket->putText(valueBucket, "data1", "zhangSan");
69 valueBucket->putInt64(valueBucket, "data2", 12800);
70 valueBucket->putReal(valueBucket, "data3", 100.1);
71 uint8_t arr[] = { 1, 2, 3, 4, 5 };
72 int len = sizeof(arr) / sizeof(arr[0]);
73 valueBucket->putBlob(valueBucket, "data4", arr, len);
74 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
75 errCode = OH_Rdb_Insert(cursorTestRdbStore_, table, valueBucket);
76 EXPECT_EQ(errCode, 1);
77
78 valueBucket->clear(valueBucket);
79 valueBucket->putInt64(valueBucket, "id", 2);
80 valueBucket->putText(valueBucket, "data1", "liSi");
81 valueBucket->putInt64(valueBucket, "data2", 13800);
82 valueBucket->putReal(valueBucket, "data3", 200.1);
83 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
84 errCode = OH_Rdb_Insert(cursorTestRdbStore_, table, valueBucket);
85 EXPECT_EQ(errCode, 2);
86
87 valueBucket->clear(valueBucket);
88 valueBucket->putInt64(valueBucket, "id", 3);
89 valueBucket->putText(valueBucket, "data1", "wangWu");
90 valueBucket->putInt64(valueBucket, "data2", 14800);
91 valueBucket->putReal(valueBucket, "data3", 300.1);
92 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
93 errCode = OH_Rdb_Insert(cursorTestRdbStore_, table, valueBucket);
94 EXPECT_EQ(errCode, 3);
95
96 valueBucket->destroy(valueBucket);
97 CreateAssetTable();
98 }
99
TearDownTestCase(void)100 void RdbNativeCursorTest::TearDownTestCase(void)
101 {
102 delete cursorTestRdbStore_;
103 cursorTestRdbStore_ = NULL;
104 OH_Rdb_DeleteStore(&config_);
105 }
106
SetUp(void)107 void RdbNativeCursorTest::SetUp(void)
108 {
109 }
110
TearDown(void)111 void RdbNativeCursorTest::TearDown(void)
112 {
113 }
114
CreateAssetTable()115 void RdbNativeCursorTest::CreateAssetTable()
116 {
117 char createTableSql[] = "CREATE TABLE IF NOT EXISTS asset_table (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 "
118 "asset, data2 assets );";
119 int errCode = OH_Rdb_Execute(cursorTestRdbStore_, createTableSql);
120 EXPECT_EQ(errCode, RDB_OK);
121 char table[] = "asset_table";
122 int assetsCount = 2;
123 int curRow = 1;
124 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
125 Data_Asset *asset1 = OH_Data_Asset_CreateOne();
126 SetAsset(asset1, 1);
127 Data_Asset *asset2 = OH_Data_Asset_CreateOne();
128 SetAsset(asset2, 2);
129
130 valueBucket->putInt64(valueBucket, "id", curRow);
131 OH_VBucket_PutAsset(valueBucket, "data1", asset1);
132 Data_Asset **assets1 = OH_Data_Asset_CreateMultiple(assetsCount);
133 SetAsset(assets1[0], 1);
134 SetAsset(assets1[1], 2);
135 errCode = OH_VBucket_PutAssets(valueBucket, "data2", assets1, assetsCount);
136 int rowID = OH_Rdb_Insert(cursorTestRdbStore_, table, valueBucket);
137 EXPECT_EQ(rowID, curRow);
138 curRow++;
139
140 valueBucket->clear(valueBucket);
141 valueBucket->putInt64(valueBucket, "id", curRow);
142 OH_VBucket_PutAsset(valueBucket, "data1", asset2);
143 Data_Asset **assets2 = OH_Data_Asset_CreateMultiple(assetsCount);
144 SetAsset(assets2[0], 1);
145 SetAsset(assets2[1], 3);
146 errCode = OH_VBucket_PutAssets(valueBucket, "data2", assets2, assetsCount);
147 rowID = OH_Rdb_Insert(cursorTestRdbStore_, table, valueBucket);
148 EXPECT_EQ(rowID, curRow);
149
150 OH_Data_Asset_DestroyMultiple(assets1, assetsCount);
151 OH_Data_Asset_DestroyMultiple(assets2, assetsCount);
152 OH_Data_Asset_DestroyOne(asset1);
153 OH_Data_Asset_DestroyOne(asset2);
154 valueBucket->destroy(valueBucket);
155 }
156
SetAsset(Data_Asset * asset,int index)157 void RdbNativeCursorTest::SetAsset(Data_Asset *asset, int index)
158 {
159 std::string indexString = std::to_string(index);
160 std::string name;
161 name.append("name").append(indexString);
162 int errcode = OH_Data_Asset_SetName(asset, name.c_str());
163 EXPECT_EQ(errcode, RDB_OK);
164 std::string uri;
165 uri.append("uri").append(indexString);
166 errcode = OH_Data_Asset_SetUri(asset, uri.c_str());
167 EXPECT_EQ(errcode, RDB_OK);
168 std::string path;
169 path.append("path").append(indexString);
170 errcode = OH_Data_Asset_SetPath(asset, path.c_str());
171 EXPECT_EQ(errcode, RDB_OK);
172 errcode = OH_Data_Asset_SetCreateTime(asset, index);
173 EXPECT_EQ(errcode, RDB_OK);
174 errcode = OH_Data_Asset_SetModifyTime(asset, index);
175 EXPECT_EQ(errcode, RDB_OK);
176 errcode = OH_Data_Asset_SetSize(asset, index);
177 EXPECT_EQ(errcode, RDB_OK);
178 errcode = OH_Data_Asset_SetStatus(asset, Data_AssetStatus::ASSET_NORMAL);
179 EXPECT_EQ(errcode, RDB_OK);
180 }
181
182 /**
183 * @tc.name: RDB_Native_cursor_test_001
184 * @tc.desc: Normal testCase of cursor for GetColumnType.
185 * @tc.type: FUNC
186 */
187 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_001, TestSize.Level1)
188 {
189 int errCode = 0;
190 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
191
192 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
193 EXPECT_NE(cursor, NULL);
194 cursor->goToNextRow(cursor);
195
196 OH_ColumnType type;
197 errCode = cursor->getColumnType(cursor, 0, &type);
198 EXPECT_EQ(type, OH_ColumnType::TYPE_INT64);
199
200 errCode = cursor->getColumnType(cursor, 1, &type);
201 EXPECT_EQ(type, OH_ColumnType::TYPE_TEXT);
202
203 errCode = cursor->getColumnType(cursor, 2, &type);
204 EXPECT_EQ(type, OH_ColumnType::TYPE_INT64);
205
206 errCode = cursor->getColumnType(cursor, 3, &type);
207 EXPECT_EQ(type, OH_ColumnType::TYPE_REAL);
208
209 errCode = cursor->getColumnType(cursor, 4, &type);
210 EXPECT_EQ(type, OH_ColumnType::TYPE_BLOB);
211
212 errCode = cursor->getColumnType(cursor, 5, &type);
213 EXPECT_EQ(type, OH_ColumnType::TYPE_TEXT);
214
215 errCode = cursor->getColumnType(nullptr, 5, &type);
216 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
217 errCode = cursor->getColumnType(cursor, -1, &type);
218 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
219 errCode = cursor->getColumnType(cursor, 5, nullptr);
220 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
221
222 predicates->destroy(predicates);
223 cursor->destroy(cursor);
224 }
225
226 /**
227 * @tc.name: RDB_Native_cursor_test_002
228 * @tc.desc: Normal testCase of cursor for GetColumnIndex.
229 * @tc.type: FUNC
230 */
231 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_002, TestSize.Level1)
232 {
233 int errCode = 0;
234 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
235
236 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
237 EXPECT_NE(cursor, NULL);
238
239 int columnIndex;
240 errCode = cursor->getColumnIndex(cursor, "data1", &columnIndex);
241 EXPECT_EQ(columnIndex, 1);
242
243 errCode = cursor->getColumnIndex(cursor, "data2", &columnIndex);
244 EXPECT_EQ(columnIndex, 2);
245
246 errCode = cursor->getColumnIndex(cursor, "data3", &columnIndex);
247 EXPECT_EQ(columnIndex, 3);
248
249 errCode = cursor->getColumnIndex(cursor, "data4", &columnIndex);
250 EXPECT_EQ(columnIndex, 4);
251
252 errCode = cursor->getColumnIndex(cursor, "data5", &columnIndex);
253 EXPECT_EQ(columnIndex, 5);
254
255 errCode = cursor->getColumnIndex(nullptr, "data5", &columnIndex);
256 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
257 errCode = cursor->getColumnIndex(cursor, nullptr, &columnIndex);
258 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
259 errCode = cursor->getColumnIndex(cursor, "data5", nullptr);
260 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
261
262 predicates->destroy(predicates);
263 cursor->destroy(cursor);
264 }
265
266 /**
267 * @tc.name: RDB_Native_cursor_test_003
268 * @tc.desc: Normal testCase of cursor for GetColumnName.
269 * @tc.type: FUNC
270 */
271 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_003, TestSize.Level1)
272 {
273 int errCode = 0;
274 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
275
276 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
277 EXPECT_NE(cursor, NULL);
278
279 char name[10];
280 errCode = cursor->getColumnName(cursor, 1, name, 10);
281 EXPECT_EQ(strcmp(name, "data1"), 0);
282
283 errCode = cursor->getColumnName(cursor, 2, name, 6);
284 EXPECT_EQ(strcmp(name, "data2"), 0);
285
286 errCode = cursor->getColumnName(cursor, 3, name, 6);
287 EXPECT_EQ(strcmp(name, "data3"), 0);
288
289 errCode = cursor->getColumnName(cursor, 4, name, 6);
290 EXPECT_EQ(strcmp(name, "data4"), 0);
291
292 errCode = cursor->getColumnName(cursor, 5, name, 6);
293 EXPECT_EQ(strcmp(name, "data5"), 0);
294
295 errCode = cursor->getColumnName(nullptr, 5, name, 6);
296 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
297 errCode = cursor->getColumnName(cursor, 5, nullptr, 6);
298 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
299 errCode = cursor->getColumnName(cursor, 5, name, 0);
300 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
301
302 predicates->destroy(predicates);
303 cursor->destroy(cursor);
304 }
305
306 /**
307 * @tc.name: RDB_Native_cursor_test_004
308 * @tc.desc: Normal testCase of cursor for Getxxx.
309 * @tc.type: FUNC
310 */
311 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_004, TestSize.Level1)
312 {
313 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
314
315 const char *columnNames[] = { "data1", "data2", "data3", "data4" };
316 int len = sizeof(columnNames) / sizeof(columnNames[0]);
317 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, columnNames, len);
318 EXPECT_NE(cursor, NULL);
319
320 int rowCount = 0;
321 cursor->getRowCount(cursor, &rowCount);
322 EXPECT_EQ(rowCount, 3);
323
324 cursor->goToNextRow(cursor);
325
326 int columnCount = 0;
327 cursor->getColumnCount(cursor, &columnCount);
328 EXPECT_EQ(columnCount, 4);
329
330 size_t size = 0;
331 cursor->getSize(cursor, 0, &size);
332 char data1Value[size];
333 cursor->getText(cursor, 0, data1Value, size);
334 EXPECT_EQ(strcmp(data1Value, "zhangSan"), 0);
335
336 int64_t data2Value;
337 cursor->getInt64(cursor, 1, &data2Value);
338 EXPECT_EQ(data2Value, 12800);
339
340 double data3Value;
341 cursor->getReal(cursor, 2, &data3Value);
342 EXPECT_EQ(data3Value, 100.1);
343
344 cursor->getSize(cursor, 3, &size);
345 unsigned char data4Value[size];
346 cursor->getBlob(cursor, 3, data4Value, size);
347 EXPECT_EQ(data4Value[0], 1);
348 EXPECT_EQ(data4Value[1], 2);
349
350 cursor->goToNextRow(cursor);
351
352 cursor->getSize(cursor, 0, &size);
353 char data1Value1[size];
354 cursor->getText(cursor, 0, data1Value1, size);
355 EXPECT_EQ(strcmp(data1Value1, "liSi"), 0);
356
357 cursor->getInt64(cursor, 1, &data2Value);
358 EXPECT_EQ(data2Value, 13800);
359
360 cursor->getReal(cursor, 2, &data3Value);
361 EXPECT_EQ(data3Value, 200.1);
362
363 bool isNull = false;
364 cursor->isNull(cursor, 3, &isNull);
365 EXPECT_EQ(isNull, true);
366
367 predicates->destroy(predicates);
368 cursor->destroy(cursor);
369 }
370
371 /**
372 * @tc.name: RDB_Native_cursor_test_005
373 * @tc.desc: Normal testCase of cursor for anomalous branch.
374 * @tc.type: FUNC
375 */
376 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_005, TestSize.Level1)
377 {
378 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
379
380 const char *columnNames[] = { "data1", "data2", "data3", "data4" };
381 int len = sizeof(columnNames) / sizeof(columnNames[0]);
382 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, columnNames, len);
383 EXPECT_NE(cursor, NULL);
384
385 int rowCount = 0;
386 int errCode = cursor->getRowCount(nullptr, &rowCount);
387 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
388 errCode = cursor->getRowCount(cursor, nullptr);
389 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
390
391 int columnCount = 0;
392 errCode = cursor->getColumnCount(nullptr, &columnCount);
393 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
394 errCode = cursor->getColumnCount(cursor, nullptr);
395 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
396
397 errCode = cursor->goToNextRow(nullptr);
398 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
399
400 size_t size = 0;
401 errCode = cursor->getSize(nullptr, 0, &size);
402 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
403 errCode = cursor->getSize(cursor, 0, nullptr);
404 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
405
406 char data1Value[size + 1];
407 errCode = cursor->getText(nullptr, 0, data1Value, size + 1);
408 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
409 errCode = cursor->getText(cursor, 0, nullptr, size + 1);
410 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
411 errCode = cursor->getText(cursor, 0, data1Value, 0);
412 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
413
414 predicates->destroy(predicates);
415 cursor->destroy(cursor);
416 }
417
418 /**
419 * @tc.name: RDB_Native_cursor_test_006
420 * @tc.desc: Normal testCase of cursor for anomalous branch.
421 * @tc.type: FUNC
422 */
423 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_006, TestSize.Level1)
424 {
425 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
426
427 const char *columnNames[] = { "data1", "data2", "data3", "data4" };
428 int len = sizeof(columnNames) / sizeof(columnNames[0]);
429 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, columnNames, len);
430 EXPECT_NE(cursor, NULL);
431
432 int64_t data2Value;
433 int errCode = cursor->getInt64(nullptr, 1, &data2Value);
434 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
435 errCode = cursor->getInt64(cursor, 1, nullptr);
436 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
437
438 double data3Value;
439 errCode = cursor->getReal(nullptr, 2, &data3Value);
440 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
441 errCode = cursor->getReal(cursor, 2, nullptr);
442 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
443
444 size_t size = 0;
445 unsigned char data4Value[size];
446 errCode = cursor->getBlob(nullptr, 3, data4Value, size);
447 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
448 errCode = cursor->getBlob(cursor, 3, nullptr, size);
449 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
450 errCode = cursor->getBlob(cursor, 3, data4Value, 0);
451 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
452
453 bool isNull = false;
454 errCode = cursor->isNull(nullptr, 3, &isNull);
455 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
456 errCode = cursor->isNull(cursor, 3, nullptr);
457 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
458
459 errCode = cursor->destroy(nullptr);
460 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
461
462 predicates->destroy(predicates);
463 cursor->destroy(cursor);
464 }
465
466 /**
467 * @tc.name: RDB_Native_cursor_test_007
468 * @tc.desc: Normal testCase of cursor for anomalous branch.
469 * @tc.type: FUNC
470 */
471 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_007, TestSize.Level1)
472 {
473 int errCode = 0;
474 OH_Predicates *predicates = OH_Rdb_CreatePredicates("asset_table");
475
476 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
477 EXPECT_NE(cursor, NULL);
478 cursor->goToNextRow(cursor);
479
480 OH_ColumnType type;
481 errCode = cursor->getColumnType(cursor, 0, &type);
482 EXPECT_EQ(type, OH_ColumnType::TYPE_INT64);
483
484 errCode = cursor->getColumnType(cursor, 1, &type);
485 EXPECT_EQ(type, OH_ColumnType::TYPE_ASSET);
486
487 errCode = cursor->getColumnType(cursor, 2, &type);
488 EXPECT_EQ(type, OH_ColumnType::TYPE_ASSETS);
489
490 predicates->destroy(predicates);
491 cursor->destroy(cursor);
492 }
493
494 /**
495 * @tc.name: RDB_Native_cursor_test_008
496 * @tc.desc: Normal testCase of cursor for anomalous branch.
497 * @tc.type: FUNC
498 */
499 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_008, TestSize.Level1)
500 {
501 int errCode = 0;
502 OH_Predicates *predicates = OH_Rdb_CreatePredicates("asset_table");
503
504 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
505 EXPECT_NE(cursor, NULL);
506 cursor->goToNextRow(cursor);
507
508 OH_ColumnType type;
509 errCode = cursor->getColumnType(cursor, 0, &type);
510 EXPECT_EQ(type, OH_ColumnType::TYPE_INT64);
511 int64_t id;
512 errCode = cursor->getInt64(cursor, 0, &id);
513 EXPECT_EQ(id, 1);
514
515 errCode = cursor->getColumnType(cursor, 1, &type);
516 EXPECT_EQ(type, OH_ColumnType::TYPE_ASSET);
517 Data_Asset *asset = OH_Data_Asset_CreateOne();
518 errCode = cursor->getAsset(cursor, 1, asset);
519 EXPECT_NE(asset, nullptr);
520 char name[10] = "";
521 size_t nameLength = 10;
522 errCode = OH_Data_Asset_GetName(asset, name, &nameLength);
523 EXPECT_EQ(strcmp(name, "name1"), 0);
524
525 char uri[10] = "";
526 size_t uriLength = 10;
527 errCode = OH_Data_Asset_GetUri(asset, uri, &uriLength);
528 EXPECT_EQ(strcmp(uri, "uri1"), 0);
529
530 char path[10] = "";
531 size_t pathLength = 10;
532 errCode = OH_Data_Asset_GetPath(asset, path, &pathLength);
533 EXPECT_EQ(strcmp(path, "path1"), 0);
534
535 int64_t createTime = 0;
536 errCode = OH_Data_Asset_GetCreateTime(asset, &createTime);
537 EXPECT_EQ(createTime, 1);
538
539 int64_t modifyTime = 0;
540 errCode = OH_Data_Asset_GetModifyTime(asset, &modifyTime);
541 EXPECT_EQ(modifyTime, 1);
542
543 size_t size = 0;
544 errCode = OH_Data_Asset_GetSize(asset, &size);
545 EXPECT_EQ(size, 1);
546
547 Data_AssetStatus status = Data_AssetStatus::ASSET_NULL;
548 errCode = OH_Data_Asset_GetStatus(asset, &status);
549 EXPECT_EQ(status, ASSET_INSERT);
550
551 predicates->destroy(predicates);
552 OH_Data_Asset_DestroyOne(asset);
553 cursor->destroy(cursor);
554 }
555
556 /**
557 * @tc.name: RDB_Native_cursor_test_009
558 * @tc.desc: Normal testCase of cursor for getAssets.
559 * @tc.type: FUNC
560 */
561 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_009, TestSize.Level1)
562 {
563 int errCode = 0;
564 OH_Predicates *predicates = OH_Rdb_CreatePredicates("asset_table");
565
566 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
567 EXPECT_NE(cursor, NULL);
568 cursor->goToNextRow(cursor);
569
570 OH_ColumnType type;
571 errCode = cursor->getColumnType(cursor, 0, &type);
572 EXPECT_EQ(type, OH_ColumnType::TYPE_INT64);
573 int64_t id;
574 errCode = cursor->getInt64(cursor, 0, &id);
575 EXPECT_EQ(id, 1);
576
577 errCode = cursor->getColumnType(cursor, 2, &type);
578 EXPECT_EQ(type, OH_ColumnType::TYPE_ASSETS);
579 uint32_t assetCount = 0;
580 errCode = cursor->getAssets(cursor, 2, nullptr, &assetCount);
581 EXPECT_EQ(assetCount, 2);
582 Data_Asset **assets = OH_Data_Asset_CreateMultiple(assetCount);
583 errCode = cursor->getAssets(cursor, 2, assets, &assetCount);
584 EXPECT_EQ(assetCount, 2);
585 Data_Asset *asset = assets[1];
586 EXPECT_NE(asset, NULL);
587
588 char name[10] = "";
589 size_t nameLength = 10;
590 errCode = OH_Data_Asset_GetName(asset, name, &nameLength);
591 EXPECT_EQ(strcmp(name, "name2"), 0);
592
593 char uri[10] = "";
594 size_t uriLength = 10;
595 errCode = OH_Data_Asset_GetUri(asset, uri, &uriLength);
596 EXPECT_EQ(strcmp(uri, "uri2"), 0);
597
598 char path[10] = "";
599 size_t pathLength = 10;
600 errCode = OH_Data_Asset_GetPath(asset, path, &pathLength);
601 EXPECT_EQ(strcmp(path, "path2"), 0);
602
603 int64_t createTime = 0;
604 errCode = OH_Data_Asset_GetCreateTime(asset, &createTime);
605 EXPECT_EQ(createTime, 2);
606
607 int64_t modifyTime = 0;
608 errCode = OH_Data_Asset_GetModifyTime(asset, &modifyTime);
609 EXPECT_EQ(modifyTime, 2);
610
611 size_t size = 0;
612 errCode = OH_Data_Asset_GetSize(asset, &size);
613 EXPECT_EQ(size, 2);
614
615 Data_AssetStatus status = Data_AssetStatus::ASSET_NULL;
616 errCode = OH_Data_Asset_GetStatus(asset, &status);
617 EXPECT_EQ(status, ASSET_INSERT);
618
619 predicates->destroy(predicates);
620 OH_Data_Asset_DestroyMultiple(assets, assetCount);
621 cursor->destroy(cursor);
622 }
623
624 /**
625 * @tc.name: Abnormal_RDB_cursor_test_010
626 * @tc.desc: Abnormal testCase of cursor for OH_VBucket_PutAssets, OH_VBucket_PutAsset.
627 * @tc.type: FUNC
628 */
629 HWTEST_F(RdbNativeCursorTest, Abnormal_cursor_PutAssets_test_010, TestSize.Level1)
630 {
631 char table[] = "asset_table";
632 int assetsCount = 2;
633 int curRow = 3;
634
635 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
636
637 Data_Asset *asset = OH_Data_Asset_CreateOne();
638 SetAsset(asset, 1);
639
640 valueBucket->putInt64(valueBucket, "id", curRow);
641
642 int errCode = OH_VBucket_PutAsset(nullptr, "data1", asset);
643 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
644 errCode = OH_Rdb_ErrCode::RDB_OK;
645 errCode = OH_VBucket_PutAsset(valueBucket, nullptr, asset);
646 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
647 errCode = OH_Rdb_ErrCode::RDB_OK;
648 errCode = OH_VBucket_PutAsset(valueBucket, "data1", nullptr);
649 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
650
651 OH_VBucket_PutAsset(valueBucket, "data1", asset);
652 Data_Asset **assets = OH_Data_Asset_CreateMultiple(assetsCount);
653 SetAsset(assets[0], 1);
654 SetAsset(assets[1], 2);
655
656 errCode = OH_Rdb_ErrCode::RDB_OK;
657 errCode = OH_VBucket_PutAssets(nullptr, "data2", assets, assetsCount);
658 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
659 errCode = OH_Rdb_ErrCode::RDB_OK;
660 errCode = OH_VBucket_PutAssets(valueBucket, nullptr, assets, assetsCount);
661 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
662
663 errCode = OH_VBucket_PutAssets(valueBucket, "data2", assets, assetsCount);
664 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_OK);
665 int rowID = OH_Rdb_Insert(cursorTestRdbStore_, table, valueBucket);
666 EXPECT_EQ(rowID, curRow);
667
668 free(assets[1]);
669 assets[1] = nullptr;
670 errCode = OH_VBucket_PutAssets(valueBucket, nullptr, assets, assetsCount);
671 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
672
673 OH_Data_Asset_DestroyMultiple(assets, assetsCount);
674 OH_Data_Asset_DestroyOne(asset);
675 valueBucket->destroy(valueBucket);
676 }
677
678 /**
679 * @tc.name: Abnormal_cursor_GetAssets_test_011
680 * @tc.desc: Abnormal testCase of cursor for getAssets, getAsset.
681 * @tc.type: FUNC
682 */
683 HWTEST_F(RdbNativeCursorTest, Abnormal_cursor_GetAssets_test_011, TestSize.Level1)
684 {
685 int errCode = 0;
686 OH_Predicates *predicates = OH_Rdb_CreatePredicates("asset_table");
687
688 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
689 EXPECT_NE(cursor, NULL);
690 cursor->goToNextRow(cursor);
691
692 OH_ColumnType type;
693 errCode = cursor->getColumnType(cursor, 1, &type);
694 EXPECT_EQ(type, OH_ColumnType::TYPE_ASSET);
695 errCode = cursor->getColumnType(cursor, 2, &type);
696 EXPECT_EQ(type, OH_ColumnType::TYPE_ASSETS);
697
698 uint32_t assetCount = 0;
699 // if cursor is nullptr
700 errCode = cursor->getAssets(nullptr, 2, nullptr, &assetCount);
701 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
702 // if cursor is empty
703 OH_Cursor emptyCursor;
704 errCode = cursor->getAssets(&emptyCursor, 2, nullptr, &assetCount);
705 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
706 // if index is nullpry
707 errCode = cursor->getAssets(cursor, 2, nullptr, nullptr);
708 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
709 // if columnIndex < 0
710 errCode = cursor->getAssets(cursor, -1, nullptr, &assetCount);
711 EXPECT_NE(errCode, OH_Rdb_ErrCode::RDB_OK);
712
713 Data_Asset *asset = OH_Data_Asset_CreateOne();
714 EXPECT_NE(asset, NULL);
715 // if cursor is nullptr
716 errCode = cursor->getAsset(nullptr, 1, asset);
717 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
718 // if cursor is empry
719 errCode = cursor->getAsset(&emptyCursor, 1, asset);
720 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
721 // if asset is nullptr
722 errCode = cursor->getAsset(cursor, 1, nullptr);
723 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
724 // if columnIndex is < 0
725 errCode = cursor->getAsset(cursor, -1, asset);
726 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
727
728 predicates->destroy(predicates);
729 OH_Data_Asset_DestroyOne(asset);
730 cursor->destroy(cursor);
731 }
732
733 /**
734 * @tc.name: Abnormal_cursor_GetColumnName_test_012
735 * @tc.desc: invalid args test.
736 * @tc.type: FUNC
737 */
738 HWTEST_F(RdbNativeCursorTest, Abnormal_cursor_GetColumnName_test_012, TestSize.Level1)
739 {
740 size_t count = 0;
741 size_t outLen;
742 char querySql[] = "select * from test where id = ?;";
743 OH_Data_Values *values = OH_Values_Create();
744 float test[count];
745 OH_Cursor *cursor = OH_Rdb_ExecuteQueryV2(cursorTestRdbStore_, querySql, values);
746
747 auto errCode = OH_Cursor_GetFloatVectorCount(nullptr, 1, nullptr);
748 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
749 errCode = OH_Cursor_GetFloatVectorCount(cursor, 1, nullptr);
750 EXPECT_EQ(errCode, RDB_E_INVALID_ARGS);
751
752 EXPECT_EQ(RDB_E_INVALID_ARGS, OH_Cursor_GetFloatVector(nullptr, 1, nullptr, count, &outLen));
753 EXPECT_EQ(RDB_E_INVALID_ARGS, OH_Cursor_GetFloatVector(cursor, 1, nullptr, count, &outLen));
754 EXPECT_EQ(RDB_E_INVALID_ARGS, OH_Cursor_GetFloatVector(cursor, 1, test, 0, &outLen));
755 EXPECT_EQ(RDB_E_INVALID_ARGS, OH_Cursor_GetFloatVector(cursor, 1, test, count, nullptr));
756
757 Data_Asset *asset = OH_Data_Asset_CreateOne();
758
759 EXPECT_EQ(RDB_OK, OH_Data_Asset_DestroyOne(nullptr));
760 EXPECT_EQ(RDB_OK, OH_Data_Asset_DestroyOne(asset));
761 EXPECT_EQ(RDB_OK, OH_Data_Asset_DestroyMultiple(nullptr, 0));
762 }
763