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