1 /*
2 * Copyright (c) 2021 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
18 #include <chrono>
19 #include <string>
20 #include <vector>
21
22 #include "common.h"
23 #include "rdb_errno.h"
24 #include "rdb_helper.h"
25 #include "rdb_open_callback.h"
26 #include "shared_block.h"
27 #include "sqlite_shared_result_set.h"
28 #include "value_object.h"
29
30 using namespace testing::ext;
31 using namespace OHOS::NativeRdb;
32 using Asset = ValueObject::Asset;
33 using Assets = ValueObject::Assets;
34 using ValueObjects = std::vector<ValueObject>;
35 using Time = std::chrono::steady_clock::time_point;
36 class RdbSqliteSharedResultSetTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 void GenerateDefaultTable();
43 void GenerateAssetsTable();
44 void GenerateTimeoutTable();
45 void CheckResultSetAttribute(
46 std::shared_ptr<ResultSet> rstSet, int pos, bool isStart, bool isAtFirstRow, bool isEnded);
47
48 static const std::string DATABASE_NAME;
49 static std::shared_ptr<RdbStore> store;
50 };
51
52 const std::string RdbSqliteSharedResultSetTest::DATABASE_NAME = RDB_TEST_PATH + "shared_test.db";
53 std::shared_ptr<RdbStore> RdbSqliteSharedResultSetTest::store = nullptr;
54
55 class SqliteSharedOpenCallback : public RdbOpenCallback {
56 public:
57 int OnCreate(RdbStore &rdbStore) override;
58 int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override;
59 static const std::string CREATE_TABLE_TEST;
60 };
61
62 std::string const SqliteSharedOpenCallback::CREATE_TABLE_TEST = "CREATE TABLE test (id INTEGER PRIMARY KEY "
63 "AUTOINCREMENT, data1 TEXT,data2 INTEGER, data3 "
64 "FLOAT, data4 BLOB, data5 ASSET, data6 ASSETS, "
65 "data7 floatvector(128), data8 UNLIMITED INT);";
66
OnCreate(RdbStore & rdbStore)67 int SqliteSharedOpenCallback::OnCreate(RdbStore &rdbStore)
68 {
69 return rdbStore.ExecuteSql(CREATE_TABLE_TEST);
70 }
71
OnUpgrade(RdbStore & rdbStore,int oldVersion,int newVersion)72 int SqliteSharedOpenCallback::OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion)
73 {
74 return E_OK;
75 }
76
SetUpTestCase(void)77 void RdbSqliteSharedResultSetTest::SetUpTestCase(void)
78 {
79 RdbStoreConfig sqliteSharedRstConfig(RdbSqliteSharedResultSetTest::DATABASE_NAME);
80 SqliteSharedOpenCallback sqliteSharedRstHelper;
81 int errCode = E_OK;
82 RdbSqliteSharedResultSetTest::store =
83 RdbHelper::GetRdbStore(sqliteSharedRstConfig, 1, sqliteSharedRstHelper, errCode);
84 EXPECT_NE(RdbSqliteSharedResultSetTest::store, nullptr);
85 }
86
TearDownTestCase(void)87 void RdbSqliteSharedResultSetTest::TearDownTestCase(void)
88 {
89 RdbHelper::DeleteRdbStore(RdbSqliteSharedResultSetTest::DATABASE_NAME);
90 }
91
SetUp()92 void RdbSqliteSharedResultSetTest::SetUp()
93 {
94 store->ExecuteSql("DELETE FROM test");
95 }
96
TearDown()97 void RdbSqliteSharedResultSetTest::TearDown()
98 {
99 }
100
GenerateDefaultTable()101 void RdbSqliteSharedResultSetTest::GenerateDefaultTable()
102 {
103 std::shared_ptr<RdbStore> &store = RdbSqliteSharedResultSetTest::store;
104
105 int64_t id;
106 ValuesBucket values;
107 AssetValue asset {
108 .version = 0,
109 .name = "123",
110 .uri = "my test path",
111 .createTime = "12",
112 .modifyTime = "12",
113 };
114 vector<AssetValue> assets;
115 assets.push_back(asset);
116
117 values.PutInt("id", 1);
118 values.PutString("data1", std::string("hello"));
119 values.PutInt("data2", 10); // set int value 10
120 values.PutDouble("data3", 1.0);
121 values.PutBlob("data4", std::vector<uint8_t>{ 66 }); // set uint8_t value 66
122 values.Put("data5", asset);
123 values.Put("data6", assets);
124 values.Put("data7", std::vector<float>(1, 0.5)); // set float value 0.5
125 values.Put("data8", BigInteger(0));
126 store->Insert(id, "test", values);
127
128 values.Clear();
129 values.PutInt("id", 2); // set int value 2
130 values.PutString("data1", std::string("2"));
131 values.PutInt("data2", -5); // set int value -5
132 values.PutDouble("data3", 2.5); // set float value 2.5
133 values.PutBlob("data4", std::vector<uint8_t>{});
134 store->Insert(id, "test", values);
135
136 values.Clear();
137 values.PutInt("id", 3); // set int value 3
138 values.PutString("data1", std::string("hello world"));
139 values.PutInt("data2", 3); // set int value 3
140 values.PutDouble("data3", 1.8); // set float value 1.8
141 values.PutBlob("data4", std::vector<uint8_t>{});
142 store->Insert(id, "test", values);
143 }
144
GenerateAssetsTable()145 void RdbSqliteSharedResultSetTest::GenerateAssetsTable()
146 {
147 std::shared_ptr<RdbStore> &store = RdbSqliteSharedResultSetTest::store;
148 int64_t id;
149 ValuesBucket values;
150 Asset assetValue1 = Asset{ 1, Asset::STATUS_DOWNLOADING, 1, "1", "name1", "uri1", "createTime1", "modifyTime1",
151 "size1", "hash1", "path1" };
152 Asset assetValue2 = Asset{ 2, Asset::STATUS_DOWNLOADING, 2, "2", "name2", "uri2", "createTime2", "modifyTime2",
153 "size2", "hash2", "path2" };
154
155 Assets assets = Assets{ assetValue1 };
156 values.PutInt("id", 1);
157 values.Put("data5", ValueObject(assetValue1));
158 values.Put("data6", ValueObject(assets));
159 store->Insert(id, "test", values);
160
161 values.Clear();
162 Assets assets1 = Assets{ assetValue2 };
163 values.PutInt("id", 2);
164 values.Put("data5", ValueObject(assetValue2));
165 values.Put("data6", ValueObject(assets1));
166 store->Insert(id, "test", values);
167 }
168
GenerateTimeoutTable()169 void RdbSqliteSharedResultSetTest::GenerateTimeoutTable()
170 {
171 std::shared_ptr<RdbStore> &store = RdbSqliteSharedResultSetTest::store;
172 int64_t id;
173 ValuesBucket values;
174 auto timeout = static_cast<uint64_t>(
175 (std::chrono::steady_clock::now() - std::chrono::seconds(10)).time_since_epoch().count());
176
177 Asset assetValue1 = Asset{
178 1,
179 Asset::STATUS_DOWNLOADING,
180 timeout,
181 "id",
182 "name1",
183 "uri1",
184 "createTime1",
185 "modifyTime1",
186 "size1",
187 "hash1",
188 "path1",
189 };
190
191 Assets assets = Assets{ assetValue1 };
192 values.PutInt("id", 1);
193 values.Put("data5", ValueObject(assetValue1));
194 values.Put("data6", ValueObject(assets));
195 store->Insert(id, "test", values);
196 }
197
CheckResultSetAttribute(std::shared_ptr<ResultSet> rstSet,int pos,bool isStart,bool isAtFirstRow,bool isEnded)198 void RdbSqliteSharedResultSetTest::CheckResultSetAttribute(
199 std::shared_ptr<ResultSet> rstSet, int pos, bool isStart, bool isAtFirstRow, bool isEnded)
200 {
201 int position = -1;
202 int iRet = rstSet->GetRowIndex(position);
203 EXPECT_EQ(E_OK, iRet);
204 EXPECT_EQ(pos, position);
205
206 bool bResultSet = !isStart;
207 iRet = rstSet->IsStarted(bResultSet);
208 EXPECT_EQ(E_OK, iRet);
209 EXPECT_EQ(isStart, bResultSet);
210
211 bResultSet = !isAtFirstRow;
212 iRet = rstSet->IsAtFirstRow(bResultSet);
213 EXPECT_EQ(E_OK, iRet);
214 EXPECT_EQ(isAtFirstRow, bResultSet);
215
216 bResultSet = !isEnded;
217 iRet = rstSet->IsEnded(bResultSet);
218 EXPECT_EQ(E_OK, iRet);
219 EXPECT_EQ(isEnded, bResultSet);
220 }
221
222 /* *
223 * @tc.name: Sqlite_Shared_Result_Set_Asset_Timeout
224 * @tc.desc: normal testcase of SqliteSharedResultSet for move
225 * @tc.type: FUNC
226 */
227 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_Asset_Timeout, TestSize.Level1)
228 {
229 GenerateTimeoutTable();
230 std::vector<std::string> selectionArgs;
231 std::shared_ptr<ResultSet> rstSet =
232 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
233 EXPECT_NE(rstSet, nullptr);
234
235 int ret = rstSet->GoToRow(0);
236 EXPECT_EQ(ret, E_OK);
237
238 int rowCnt = -1;
239 ret = rstSet->GetRowCount(rowCnt);
240 EXPECT_EQ(rowCnt, 1);
241
242 Asset asset;
243 rstSet->GetAsset(5, asset);
244 EXPECT_EQ(asset.version, 1);
245 EXPECT_EQ(asset.name, "name1");
246 EXPECT_EQ(asset.uri, "uri1");
247 EXPECT_EQ(asset.status, Asset::STATUS_INSERT);
248 }
249
250 /* *
251 * @tc.name: Sqlite_Shared_Result_Set_Asset
252 * @tc.desc: normal testcase of SqliteSharedResultSet for asset and assets
253 * @tc.type: FUNC
254 */
255 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_Asset, TestSize.Level1)
256 {
257 GenerateAssetsTable();
258 std::vector<std::string> selectionArgs;
259 std::shared_ptr<ResultSet> rstSet =
260 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
261 EXPECT_NE(rstSet, nullptr);
262
263 int ret = rstSet->GoToRow(0);
264 EXPECT_EQ(ret, E_OK);
265
266 int rowCnt = -1;
267 ret = rstSet->GetRowCount(rowCnt);
268 EXPECT_EQ(rowCnt, 2);
269
270 std::string colName = "";
271 rstSet->GetColumnName(5, colName);
272 EXPECT_EQ(colName, "data5");
273
274 rstSet->GetColumnName(6, colName);
275 EXPECT_EQ(colName, "data6");
276
277 Asset asset;
278 rstSet->GetAsset(5, asset);
279 EXPECT_EQ(asset.version, 1);
280 EXPECT_EQ(asset.name, "name1");
281 EXPECT_EQ(asset.uri, "uri1");
282 EXPECT_EQ(asset.status, AssetValue::STATUS_INSERT);
283
284 Assets assets;
285 rstSet->GetAssets(6, assets);
286 EXPECT_EQ(assets.size(), 1);
287 auto it = assets.begin();
288 EXPECT_EQ(it->version, 1);
289 EXPECT_EQ(it->name, "name1");
290 EXPECT_EQ(it->uri, "uri1");
291 EXPECT_EQ(it->status, AssetValue::STATUS_INSERT);
292
293 ret = rstSet->GoToRow(1);
294 EXPECT_EQ(ret, E_OK);
295
296 rstSet->GetAsset(5, asset);
297 EXPECT_EQ(asset.version, 2);
298 EXPECT_EQ(asset.name, "name2");
299 EXPECT_EQ(asset.uri, "uri2");
300 EXPECT_EQ(asset.status, AssetValue::STATUS_INSERT);
301
302 rstSet->GetAssets(6, assets);
303 EXPECT_EQ(assets.size(), 1);
304 it = assets.begin();
305 EXPECT_EQ(it->version, 2);
306 EXPECT_EQ(it->name, "name2");
307 EXPECT_EQ(it->uri, "uri2");
308 EXPECT_EQ(it->status, AssetValue::STATUS_INSERT);
309
310 rstSet->Close();
311 bool isClosedFlag = rstSet->IsClosed();
312 EXPECT_EQ(isClosedFlag, true);
313 }
314
315 /* *
316 * @tc.name: RdbStore_Delete_001
317 * @tc.desc: normal testcase of SqliteSharedResultSet for move
318 * @tc.type: FUNC
319 */
320 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_001, TestSize.Level1)
321 {
322 GenerateDefaultTable();
323 std::vector<std::string> selectionArgs;
324 std::shared_ptr<ResultSet> rstSet =
325 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
326 EXPECT_NE(rstSet, nullptr);
327
328 int ret = rstSet->GoToRow(1);
329 EXPECT_EQ(ret, E_OK);
330
331 int rowCnt = -1;
332 ret = rstSet->GetRowCount(rowCnt);
333 EXPECT_EQ(rowCnt, 3);
334
335 std::string colName = "";
336 rstSet->GetColumnName(1, colName);
337 EXPECT_EQ(colName, "data1");
338
339 rstSet->GetColumnName(2, colName);
340 EXPECT_EQ(colName, "data2");
341
342 rstSet->GetColumnName(3, colName);
343 EXPECT_EQ(colName, "data3");
344
345 rstSet->GetColumnName(4, colName);
346 EXPECT_EQ(colName, "data4");
347
348 std::string valueStr = "";
349 rstSet->GetString(0, valueStr);
350 EXPECT_EQ(valueStr, "2");
351
352 rstSet->GetString(1, valueStr);
353 EXPECT_EQ(valueStr, "2");
354
355 int64_t valuelg = 0;
356 rstSet->GetLong(2, valuelg);
357 EXPECT_EQ(valuelg, -5);
358
359 double valueDb = 0.0;
360 rstSet->GetDouble(3, valueDb);
361 EXPECT_EQ(valueDb, 2.5);
362
363 std::vector<uint8_t> blob;
364 rstSet->GetBlob(4, blob);
365 int sz = blob.size();
366 EXPECT_EQ(sz, 0);
367
368 rstSet->GoTo(1);
369 rstSet->GetString(0, valueStr);
370 EXPECT_EQ(valueStr, "3");
371
372 rstSet->GetString(1, valueStr);
373 EXPECT_EQ(valueStr, "hello world");
374
375 rstSet->GetLong(2, valuelg);
376 EXPECT_EQ(valuelg, 3);
377
378 rstSet->GetDouble(3, valueDb);
379 EXPECT_EQ(valueDb, 1.8);
380
381 rstSet->GetBlob(4, blob);
382 sz = blob.size();
383 EXPECT_EQ(sz, 0);
384
385 bool isNull = true;
386 rstSet->IsColumnNull(4, isNull);
387 EXPECT_EQ(isNull, false);
388
389 ret = -1;
390 ret = rstSet->GoToPreviousRow();
391 EXPECT_EQ(ret, E_OK);
392 ret = -1;
393 ret = rstSet->GoToPreviousRow();
394 EXPECT_EQ(ret, E_OK);
395
396 rstSet->GetString(0, valueStr);
397 EXPECT_EQ(valueStr, "1");
398
399 rstSet->GetString(1, valueStr);
400 EXPECT_EQ(valueStr, "hello");
401
402 rstSet->GetLong(2, valuelg);
403 EXPECT_EQ(valuelg, 10);
404
405 rstSet->GetDouble(3, valueDb);
406 EXPECT_EQ(valueDb, 1.0);
407
408 rstSet->Close();
409 bool isClosedFlag = rstSet->IsClosed();
410 EXPECT_EQ(isClosedFlag, true);
411 }
412
413 /* *
414 * @tc.name: Sqlite_Shared_Result_Set_002
415 * @tc.desc: normal testcase of SqliteSharedResultSet for goToNextRow
416 * @tc.type: FUNC
417 */
418 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_002, TestSize.Level1)
419 {
420 GenerateDefaultTable();
421 std::vector<std::string> selectionArgs;
422 std::shared_ptr<ResultSet> rstSet =
423 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
424 EXPECT_NE(rstSet, nullptr);
425
426 CheckResultSetAttribute(rstSet, -1, false, false, false);
427
428 EXPECT_EQ(rstSet->GoToNextRow(), E_OK);
429 CheckResultSetAttribute(rstSet, 0, true, true, false);
430
431 EXPECT_EQ(rstSet->GoToNextRow(), E_OK);
432 CheckResultSetAttribute(rstSet, 1, true, false, false);
433
434 EXPECT_EQ(rstSet->GoToNextRow(), E_OK);
435 CheckResultSetAttribute(rstSet, 2, true, false, false);
436 bool isAtLastRow = false;
437 rstSet->IsAtLastRow(isAtLastRow);
438 EXPECT_EQ(isAtLastRow, true);
439
440 EXPECT_EQ(rstSet->GoToNextRow(), E_ROW_OUT_RANGE);
441 CheckResultSetAttribute(rstSet, 3, true, false, true);
442
443 rstSet->Close();
444 EXPECT_EQ(rstSet->IsClosed(), true);
445 }
446
447 /* *
448 * @tc.name: Sqlite_Shared_Result_Set_003
449 * @tc.desc: normal testcase of SqliteSharedResultSet for moveFirst
450 * @tc.type: FUNC
451 */
452 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_003, TestSize.Level1)
453 {
454 GenerateDefaultTable();
455 std::vector<std::string> selectionArgs;
456 std::shared_ptr<ResultSet> rstSet =
457 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
458 EXPECT_NE(rstSet, nullptr);
459
460 int retF = rstSet->GoToFirstRow();
461 EXPECT_EQ(retF, E_OK);
462 int index = -1;
463 rstSet->GetRowIndex(index);
464 EXPECT_EQ(index, 0);
465 bool isAtFirstRow = false;
466 rstSet->IsAtFirstRow(isAtFirstRow);
467 EXPECT_EQ(isAtFirstRow, true);
468 bool isStd = false;
469 rstSet->IsStarted(isStd);
470 EXPECT_EQ(isStd, true);
471
472 int retN = rstSet->GoToNextRow();
473 EXPECT_EQ(retN, E_OK);
474 rstSet->GetRowIndex(index);
475 EXPECT_EQ(index, 1);
476 isAtFirstRow = true;
477 rstSet->IsAtFirstRow(isAtFirstRow);
478 EXPECT_EQ(isAtFirstRow, false);
479 isStd = false;
480 rstSet->IsStarted(isStd);
481 EXPECT_EQ(isStd, true);
482
483 int retGf = rstSet->GoToFirstRow();
484 EXPECT_EQ(retGf, E_OK);
485 rstSet->GetRowIndex(index);
486 EXPECT_EQ(index, 0);
487 isAtFirstRow = false;
488 rstSet->IsAtFirstRow(isAtFirstRow);
489 EXPECT_EQ(isAtFirstRow, true);
490 isStd = false;
491 rstSet->IsStarted(isStd);
492 EXPECT_EQ(isStd, true);
493
494 rstSet->Close();
495 bool isClosedFlag = rstSet->IsClosed();
496 EXPECT_EQ(isClosedFlag, true);
497 }
498
499 /* *
500 * @tc.name: Sqlite_Shared_Result_Set_004
501 * @tc.desc: normal testcase of SqliteSharedResultSet for getInt
502 * @tc.type: FUNC
503 */
504 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_004, TestSize.Level1)
505 {
506 GenerateDefaultTable();
507 std::vector<std::string> selectionArgs;
508 std::shared_ptr<ResultSet> rstSet =
509 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
510 EXPECT_NE(rstSet, nullptr);
511
512 int64_t valueInt = 0;
513 int ret = rstSet->GetLong(0, valueInt);
514 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
515
516 int retF = rstSet->GoToFirstRow();
517 EXPECT_EQ(retF, E_OK);
518 rstSet->GetLong(0, valueInt);
519 EXPECT_EQ(valueInt, 1);
520 rstSet->GetLong(2, valueInt);
521 EXPECT_EQ(valueInt, 10);
522 rstSet->GetLong(3, valueInt);
523 EXPECT_EQ(valueInt, 1);
524
525 int retN = rstSet->GoToNextRow();
526 EXPECT_EQ(retN, E_OK);
527 rstSet->GetLong(0, valueInt);
528 EXPECT_EQ(valueInt, 2);
529 valueInt = 0;
530 rstSet->GetLong(0, valueInt);
531 EXPECT_EQ(valueInt, 2);
532 valueInt = 0;
533 rstSet->GetLong(1, valueInt);
534 EXPECT_EQ(valueInt, 2);
535
536 rstSet->Close();
537 bool isClosedFlag = rstSet->IsClosed();
538 EXPECT_EQ(isClosedFlag, true);
539 }
540
541 /* *
542 * @tc.name: Sqlite_Shared_Result_Set_005
543 * @tc.desc: normal testcase of SqliteSharedResultSet for getString
544 * @tc.type: FUNC
545 */
546
547 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_005, TestSize.Level1)
548 {
549 GenerateDefaultTable();
550 std::vector<std::string> selectionArgs;
551 std::shared_ptr<ResultSet> rstSet =
552 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
553 EXPECT_NE(rstSet, nullptr);
554
555 std::string valueStr = "";
556 int ret1 = rstSet->GetString(0, valueStr);
557 EXPECT_EQ(ret1, E_ROW_OUT_RANGE);
558
559 int retF = rstSet->GoToFirstRow();
560 EXPECT_EQ(retF, E_OK);
561 valueStr = "";
562 rstSet->GetString(1, valueStr);
563 EXPECT_EQ(valueStr, "hello");
564 rstSet->GetString(2, valueStr);
565 EXPECT_EQ(valueStr, "10");
566 rstSet->GetString(3, valueStr);
567 EXPECT_EQ(valueStr, "1");
568
569 int ret2 = rstSet->GetString(4, valueStr);
570 EXPECT_EQ(ret2, E_OK);
571
572 valueStr = "";
573 int colCnt = 0;
574 rstSet->GetColumnCount(colCnt);
575 int ret3 = rstSet->GetString(colCnt, valueStr);
576 EXPECT_EQ(ret3, E_COLUMN_OUT_RANGE);
577
578 int retN = rstSet->GoToNextRow();
579 EXPECT_EQ(retN, E_OK);
580 rstSet->GetString(0, valueStr);
581 EXPECT_EQ(valueStr, "2");
582 valueStr = "";
583 rstSet->GetString(1, valueStr);
584 EXPECT_EQ(valueStr, "2");
585 rstSet->GetString(2, valueStr);
586 EXPECT_EQ(valueStr, "-5");
587 rstSet->GetString(3, valueStr);
588 EXPECT_EQ(valueStr, "2.5");
589
590 rstSet->Close();
591 bool isClosedFlag = rstSet->IsClosed();
592 EXPECT_EQ(isClosedFlag, true);
593 }
594
595 /* *
596 * @tc.name: Sqlite_Shared_Result_Set_006
597 * @tc.desc: normal testcase of SqliteSharedResultSet for getDouble
598 * @tc.type: FUNC
599 */
600 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_006, TestSize.Level1)
601 {
602 GenerateDefaultTable();
603 std::vector<std::string> selectionArgs;
604 std::shared_ptr<ResultSet> rstSet =
605 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
606 EXPECT_NE(rstSet, nullptr);
607
608 double valueDb = 0.0;
609 int ret = rstSet->GetDouble(0, valueDb);
610 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
611
612 int retF = rstSet->GoToFirstRow();
613 EXPECT_EQ(retF, E_OK);
614 rstSet->GetDouble(0, valueDb);
615 EXPECT_EQ(valueDb, 1.0);
616 std::string valueStr = "";
617 rstSet->GetString(1, valueStr);
618 EXPECT_EQ(valueStr, "hello");
619 rstSet->GetDouble(2, valueDb);
620 EXPECT_EQ(valueDb, 10.0);
621 rstSet->GetDouble(3, valueDb);
622 EXPECT_EQ(valueDb, 1.0);
623
624 int colCnt = 0;
625 rstSet->GetColumnCount(colCnt);
626 int ret1 = rstSet->GetDouble(colCnt, valueDb);
627 EXPECT_EQ(ret1, E_COLUMN_OUT_RANGE);
628
629 int retN = rstSet->GoToNextRow();
630 EXPECT_EQ(retN, E_OK);
631 rstSet->GetDouble(0, valueDb);
632 EXPECT_EQ(valueDb, 2.0);
633 valueDb = 0.0;
634 rstSet->GetDouble(1, valueDb);
635 EXPECT_EQ(valueDb, 2.0);
636
637 rstSet->GetDouble(2, valueDb);
638 EXPECT_EQ(valueDb, -5.0);
639 rstSet->GetDouble(3, valueDb);
640 EXPECT_EQ(valueDb, 2.5);
641
642 rstSet->Close();
643 bool isClosedFlag = rstSet->IsClosed();
644 EXPECT_EQ(isClosedFlag, true);
645 }
646
647 /* *
648 * @tc.name: Sqlite_Shared_Result_Set_007
649 * @tc.desc: normal testcase of SqliteSharedResultSet for getBlob
650 * @tc.type: FUNC
651 */
652 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_007, TestSize.Level1)
653 {
654 GenerateDefaultTable();
655 std::vector<std::string> selectionArgs;
656 std::shared_ptr<ResultSet> rstSet =
657 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
658 EXPECT_NE(rstSet, nullptr);
659
660 int retF = rstSet->GoToFirstRow();
661 EXPECT_EQ(retF, E_OK);
662
663 std::vector<uint8_t> blobVec;
664 rstSet->GetBlob(4, blobVec);
665 EXPECT_EQ(blobVec[0], 66);
666
667 int retN = rstSet->GoToNextRow();
668 EXPECT_EQ(retN, E_OK);
669 blobVec.clear();
670 rstSet->GetBlob(4, blobVec);
671 int blobSz = blobVec.size();
672 EXPECT_EQ(blobSz, 0);
673
674 int retN1 = rstSet->GoToNextRow();
675 EXPECT_EQ(retN1, E_OK);
676 blobVec.clear();
677 rstSet->GetBlob(4, blobVec);
678 EXPECT_EQ(blobSz, 0);
679
680 rstSet->Close();
681 bool isClosedFlag = rstSet->IsClosed();
682 EXPECT_EQ(isClosedFlag, true);
683 }
684
685 /* *
686 * @tc.name: Sqlite_Shared_Result_Set_008
687 * @tc.desc: normal testcase of SqliteSharedResultSet for getColumnTypeForIndex
688 * @tc.type: FUNC
689 */
690
691 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_008, TestSize.Level1)
692 {
693 GenerateDefaultTable();
694 std::vector<std::string> selectionArgs;
695 std::shared_ptr<ResultSet> rstSet =
696 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
697 EXPECT_NE(rstSet, nullptr);
698
699 ColumnType colType;
700 int ret = rstSet->GetColumnType(0, colType);
701 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
702 int retF = rstSet->GoToFirstRow();
703 EXPECT_EQ(retF, E_OK);
704
705 rstSet->GetColumnType(0, colType);
706 EXPECT_EQ(colType, ColumnType::TYPE_INTEGER);
707 rstSet->GetColumnType(1, colType);
708 EXPECT_EQ(colType, ColumnType::TYPE_STRING);
709 rstSet->GetColumnType(2, colType);
710 EXPECT_EQ(colType, ColumnType::TYPE_INTEGER);
711 rstSet->GetColumnType(3, colType);
712 EXPECT_EQ(colType, ColumnType::TYPE_FLOAT);
713 rstSet->GetColumnType(4, colType);
714 EXPECT_EQ(colType, ColumnType::TYPE_BLOB);
715 rstSet->GetColumnType(5, colType);
716 EXPECT_EQ(colType, ColumnType::TYPE_ASSET);
717 rstSet->GetColumnType(6, colType);
718 EXPECT_EQ(colType, ColumnType::TYPE_ASSETS);
719 rstSet->GetColumnType(7, colType);
720 EXPECT_EQ(colType, ColumnType::TYPE_FLOAT32_ARRAY);
721 rstSet->GetColumnType(8, colType);
722 EXPECT_EQ(colType, ColumnType::TYPE_BIGINT);
723
724 int colCnt = 0;
725 rstSet->GetColumnCount(colCnt);
726 int ret1 = rstSet->GetColumnType(colCnt, colType);
727 EXPECT_EQ(ret1, E_COLUMN_OUT_RANGE);
728
729 rstSet->Close();
730 bool isClosedFlag = rstSet->IsClosed();
731 EXPECT_EQ(isClosedFlag, true);
732 }
733
734 /* *
735 * @tc.name: Sqlite_Shared_Result_Set_009
736 * @tc.desc: normal testcase of SqliteSharedResultSet for getColumnIndexForName
737 * @tc.type: FUNC
738 */
739 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_009, TestSize.Level1)
740 {
741 GenerateDefaultTable();
742 std::vector<std::string> selectionArgs;
743 std::shared_ptr<ResultSet> rstSet =
744 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
745 EXPECT_NE(rstSet, nullptr);
746
747 int colIndex = 0;
748 rstSet->GetColumnIndex("data1", colIndex);
749 EXPECT_EQ(colIndex, 1);
750
751 rstSet->GetColumnIndex("data2", colIndex);
752 EXPECT_EQ(colIndex, 2);
753
754 rstSet->GetColumnIndex("data3", colIndex);
755 EXPECT_EQ(colIndex, 3);
756
757 rstSet->GetColumnIndex("data4", colIndex);
758 EXPECT_EQ(colIndex, 4);
759
760 int errCode = rstSet->GetColumnIndex("datax", colIndex);
761 EXPECT_EQ(colIndex, -1);
762 EXPECT_EQ(errCode, E_INVALID_ARGS);
763
764 rstSet->Close();
765 bool isClosedFlag = rstSet->IsClosed();
766 EXPECT_EQ(isClosedFlag, true);
767 }
768
769 /* *
770 * @tc.name: Sqlite_Shared_Result_Set_010
771 * @tc.desc: normal testcase of SqliteSharedResultSet for getColumnNameForIndex
772 * @tc.type: FUNC
773 */
774 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_010, TestSize.Level1)
775 {
776 GenerateDefaultTable();
777 std::vector<std::string> selectionArgs;
778 std::shared_ptr<ResultSet> rstSet =
779 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
780 EXPECT_NE(rstSet, nullptr);
781
782 std::vector<std::string> allColNamesVec;
783 rstSet->GetAllColumnNames(allColNamesVec);
784
785 std::string colName = "";
786 rstSet->GetColumnName(1, colName);
787 EXPECT_EQ(colName, "data1");
788 EXPECT_EQ(allColNamesVec[1], colName);
789
790 rstSet->GetColumnName(2, colName);
791 EXPECT_EQ(colName, "data2");
792 EXPECT_EQ(allColNamesVec[2], colName);
793
794 rstSet->GetColumnName(3, colName);
795 EXPECT_EQ(colName, "data3");
796 rstSet->GetColumnName(4, colName);
797 EXPECT_EQ(colName, "data4");
798
799 int colCnt = 0;
800 rstSet->GetColumnCount(colCnt);
801 int ret = rstSet->GetColumnName(colCnt, colName);
802 EXPECT_EQ(ret, E_COLUMN_OUT_RANGE);
803
804 rstSet->Close();
805 bool isClosedFlag = rstSet->IsClosed();
806 EXPECT_EQ(isClosedFlag, true);
807 }
808
809 /* *
810 * @tc.name: Sqlite_Shared_Result_Set_011
811 * @tc.desc: normal testcase of SqliteSharedResultSet
812 * @tc.type: FUNC
813 */
814 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_011, TestSize.Level1)
815 {
816 GenerateDefaultTable();
817 std::vector<std::string> selectionArgs;
818 std::shared_ptr<ResultSet> rstSet =
819 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
820 EXPECT_NE(rstSet, nullptr);
821
822 int retF = rstSet->GoToFirstRow();
823 EXPECT_EQ(retF, E_OK);
824
825 bool isAtFrtRow = false;
826 rstSet->IsAtFirstRow(isAtFrtRow);
827 EXPECT_EQ(isAtFrtRow, true);
828
829 bool isStarted = false;
830 rstSet->IsStarted(isStarted);
831 EXPECT_EQ(isStarted, true);
832
833 int64_t valueInt = 0;
834 rstSet->GetLong(2, valueInt);
835 EXPECT_EQ(valueInt, 10);
836
837 rstSet->Close();
838 bool isClosedFlag = rstSet->IsClosed();
839 EXPECT_EQ(isClosedFlag, true);
840 }
841
842 /* *
843 * @tc.name: Sqlite_Shared_Result_Set_012
844 * @tc.desc: normal testcase of SqliteSharedResultSet for getLong
845 * @tc.type: FUNC
846 */
847 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_012, TestSize.Level1)
848 {
849 GenerateDefaultTable();
850 std::vector<std::string> selectionArgs;
851 std::shared_ptr<ResultSet> rstSet =
852 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
853 EXPECT_NE(rstSet, nullptr);
854
855 int64_t valueInt = 0;
856 int ret = rstSet->GetLong(0, valueInt);
857 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
858
859 int retF = rstSet->GoToFirstRow();
860 EXPECT_EQ(retF, E_OK);
861 rstSet->GetLong(0, valueInt);
862 EXPECT_EQ(valueInt, 1.0);
863 std::string valueStr = "";
864 rstSet->GetString(1, valueStr);
865 EXPECT_EQ(valueStr, "hello");
866 rstSet->GetLong(2, valueInt);
867 EXPECT_EQ(valueInt, 10.0);
868 rstSet->GetLong(3, valueInt);
869 EXPECT_EQ(valueInt, 1.0);
870
871 int colCnt = 0;
872 rstSet->GetColumnCount(colCnt);
873 int ret1 = rstSet->GetLong(colCnt, valueInt);
874 EXPECT_EQ(ret1, E_COLUMN_OUT_RANGE);
875
876 int retN = rstSet->GoToNextRow();
877 EXPECT_EQ(retN, E_OK);
878 rstSet->GetLong(0, valueInt);
879 EXPECT_EQ(valueInt, 2.0);
880 valueInt = 0;
881 rstSet->GetLong(1, valueInt);
882 EXPECT_EQ(valueInt, 2.0);
883 rstSet->GetLong(2, valueInt);
884 EXPECT_EQ(valueInt, -5.0);
885
886 rstSet->Close();
887 bool isClosedFlag = rstSet->IsClosed();
888 EXPECT_EQ(isClosedFlag, true);
889 }
890
891 /* *
892 * @tc.name: Sqlite_Shared_Result_Set_013
893 * @tc.desc: normal testcase of SqliteSharedResultSet for fillBlock
894 * @tc.type: FUNC
895 */
896 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_013, TestSize.Level1)
897 {
898 GenerateDefaultTable();
899 std::vector<std::string> selectionArgs;
900 std::shared_ptr<ResultSet> rstSet =
901 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
902 EXPECT_NE(rstSet, nullptr);
903
904 SqliteSharedResultSet *pSqlSharedRstSet = static_cast<SqliteSharedResultSet *>(rstSet.get());
905 bool isBk = pSqlSharedRstSet->HasBlock();
906 EXPECT_EQ(isBk, true);
907
908 rstSet->Close();
909 bool isClosedFlag = rstSet->IsClosed();
910 EXPECT_EQ(isClosedFlag, true);
911 }
912 /* *
913 * @tc.name: Sqlite_Shared_Result_Set_014
914 * @tc.desc: normal testcase of SqliteSharedResultSet for getBlock
915 * @tc.type: FUNC
916 */
917 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_014, TestSize.Level1)
918 {
919 GenerateDefaultTable();
920 std::vector<std::string> selectionArgs;
921 std::shared_ptr<ResultSet> rstSet =
922 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
923 EXPECT_NE(rstSet, nullptr);
924
925 SqliteSharedResultSet *pSqlSharedRstSet = static_cast<SqliteSharedResultSet *>(rstSet.get());
926 bool isBk = pSqlSharedRstSet->HasBlock();
927 EXPECT_EQ(isBk, true);
928
929 int retF = rstSet->GoToFirstRow();
930 EXPECT_EQ(retF, E_OK);
931 auto pBk = pSqlSharedRstSet->GetBlock();
932 EXPECT_NE(pBk, nullptr);
933
934 std::string path = RdbSqliteSharedResultSetTest::store->GetPath();
935 std::string path1 = pBk->Name();
936
937 EXPECT_EQ(path, "/data/test/shared_test.db");
938 EXPECT_EQ(path1, "/data/test/shared_test.db");
939
940 rstSet->Close();
941 bool isClosedFlag = rstSet->IsClosed();
942 EXPECT_EQ(isClosedFlag, true);
943 }
944 /* *
945 * @tc.name: Sqlite_Shared_Result_Set_015
946 * @tc.desc: normal testcase of SqliteSharedResultSet for setBlock
947 * @tc.type: FUNC
948 */
949 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_015, TestSize.Level1)
950 {
951 GenerateDefaultTable();
952 std::vector<std::string> selectionArgs;
953 std::shared_ptr<ResultSet> rstSet =
954 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
955 EXPECT_NE(rstSet, nullptr);
956
957 SqliteSharedResultSet *pSqlSharedRstSet = static_cast<SqliteSharedResultSet *>(rstSet.get());
958 bool isBk = pSqlSharedRstSet->HasBlock();
959 EXPECT_EQ(isBk, true);
960
961 int retN = rstSet->GoToNextRow();
962 EXPECT_EQ(retN, E_OK);
963
964 std::string path = RdbSqliteSharedResultSetTest::store->GetPath();
965 auto pBk = pSqlSharedRstSet->GetBlock();
966 std::string path1 = pBk->Name();
967
968 EXPECT_EQ(path, "/data/test/shared_test.db");
969 EXPECT_EQ(path1, "/data/test/shared_test.db");
970
971 rstSet->Close();
972 bool isClosedFlag = rstSet->IsClosed();
973 EXPECT_EQ(isClosedFlag, true);
974 }
975
976 /* *
977 * @tc.name: Sqlite_Shared_Result_Set_016
978 * @tc.desc: normal testcase of SqliteSharedResultSet for setFillWindowForwardOnly
979 * @tc.type: FUNC
980 */
981 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_016, TestSize.Level1)
982 {
983 GenerateDefaultTable();
984 std::vector<std::string> selectionArgs;
985 std::shared_ptr<ResultSet> rstSet =
986 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
987 EXPECT_NE(rstSet, nullptr);
988
989 SqliteSharedResultSet *pSqlSharedRstSet = static_cast<SqliteSharedResultSet *>(rstSet.get());
990 bool isBk = pSqlSharedRstSet->HasBlock();
991 EXPECT_EQ(isBk, true);
992
993 pSqlSharedRstSet->PickFillBlockStartPosition(0, 0);
994 pSqlSharedRstSet->SetFillBlockForwardOnly(true);
995 pSqlSharedRstSet->GoToFirstRow();
996
997 auto pBk = pSqlSharedRstSet->GetBlock();
998 EXPECT_NE(pBk, nullptr);
999 std::string path = RdbSqliteSharedResultSetTest::store->GetPath();
1000 std::string path1 = pBk->Name();
1001
1002 EXPECT_EQ(path, "/data/test/shared_test.db");
1003 EXPECT_EQ(path1, "/data/test/shared_test.db");
1004
1005 int rowCnt = 0;
1006 pSqlSharedRstSet->GetRowCount(rowCnt);
1007 int rowCntBk = pBk->GetRowNum();
1008
1009 EXPECT_EQ(rowCnt, rowCntBk);
1010
1011 rstSet->Close();
1012 bool isClosedFlag = rstSet->IsClosed();
1013 EXPECT_EQ(isClosedFlag, true);
1014 }
1015
1016 /* *
1017 * @tc.name: Sqlite_Shared_Result_Set_017
1018 * @tc.desc: normal testcase of SqliteSharedResultSet for setExtensions and getExtensions
1019 * @tc.type: FUNC
1020 */
1021 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_017, TestSize.Level1)
1022 {
1023 GenerateDefaultTable();
1024 std::vector<std::string> selectionArgs;
1025 std::shared_ptr<ResultSet> rstSet =
1026 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1027 EXPECT_NE(rstSet, nullptr);
1028
1029 int rowCnt = 0;
1030 rstSet->GetRowCount(rowCnt);
1031 EXPECT_EQ(rowCnt, 3);
1032 int ret = rstSet->GoToLastRow();
1033 EXPECT_EQ(ret, E_OK);
1034 }
1035
1036 /* *
1037 * @tc.name: Sqlite_Shared_Result_Set_018
1038 * @tc.desc: frequency testcase of SqliteSharedResultSet for getColumnIndexForName
1039 * @tc.type: FUNC
1040 * @tc.require: issue
1041 */
1042 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_018, TestSize.Level1)
1043 {
1044 GenerateDefaultTable();
1045 std::shared_ptr<ResultSet> resultSet = RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test");
1046 EXPECT_NE(resultSet, nullptr);
1047
1048 int columnIndex = 0;
1049 for (int i = 0; i < 100; i++) {
1050 resultSet->GetColumnIndex("datax", columnIndex);
1051 EXPECT_EQ(columnIndex, -1);
1052
1053 resultSet->GetColumnIndex("data4", columnIndex);
1054 EXPECT_EQ(columnIndex, 4);
1055
1056 resultSet->GetColumnIndex("data3", columnIndex);
1057 EXPECT_EQ(columnIndex, 3);
1058
1059 resultSet->GetColumnIndex("data2", columnIndex);
1060 EXPECT_EQ(columnIndex, 2);
1061
1062 resultSet->GetColumnIndex("data1", columnIndex);
1063 EXPECT_EQ(columnIndex, 1);
1064 }
1065
1066 resultSet->Close();
1067 bool closeFlag = resultSet->IsClosed();
1068 EXPECT_EQ(closeFlag, true);
1069 }
1070
1071 /* *
1072 * @tc.name: Sqlite_Shared_Result_Set_019
1073 * @tc.desc: normal testcase of SqliteSharedResultSet for GetRow
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_019, TestSize.Level1)
1077 {
1078 GenerateDefaultTable();
1079 std::vector<std::string> selectionArgs;
1080 std::shared_ptr<AbsResultSet> resultSet =
1081 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1082 EXPECT_NE(resultSet, nullptr);
1083
1084 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1085
1086 int iRet = E_ERROR;
1087 RowEntity rowEntity;
1088 iRet = resultSet->GetRow(rowEntity);
1089 EXPECT_EQ(E_OK, iRet);
1090
1091 int idValue = rowEntity.Get("id");
1092 std::string data1Value = rowEntity.Get("data1");
1093 int data2Value = rowEntity.Get("data2");
1094 double data3Value = rowEntity.Get("data3");
1095 std::vector<uint8_t> data4Value = rowEntity.Get("data4");
1096 EXPECT_EQ(1, idValue);
1097 EXPECT_EQ("hello", data1Value);
1098 EXPECT_EQ(10, data2Value);
1099 EXPECT_EQ(1.0, data3Value);
1100 EXPECT_EQ(66, data4Value[0]);
1101
1102 int idValueByIndex = rowEntity.Get(0);
1103 std::string data1ValueByIndex = rowEntity.Get(1);
1104 int data2ValueByIndex = rowEntity.Get(2);
1105 double data3ValueByIndex = rowEntity.Get(3);
1106 std::vector<uint8_t> data4ValueByIndex = rowEntity.Get(4);
1107 EXPECT_EQ(1, idValueByIndex);
1108 EXPECT_EQ("hello", data1ValueByIndex);
1109 EXPECT_EQ(10, data2ValueByIndex);
1110 EXPECT_EQ(1.0, data3ValueByIndex);
1111 EXPECT_EQ(66, data4ValueByIndex[0]);
1112 }
1113
1114 /* *
1115 * @tc.name: Sqlite_Shared_Result_Set_020
1116 * @tc.desc: normal testcase of SqliteSharedResultSet for GetRow
1117 * @tc.type: FUNC
1118 */
1119 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_020, TestSize.Level1)
1120 {
1121 GenerateDefaultTable();
1122 std::vector<std::string> selectionArgs;
1123 std::shared_ptr<AbsResultSet> resultSet =
1124 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT data1, data2 FROM test", selectionArgs);
1125 EXPECT_NE(resultSet, nullptr);
1126
1127 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1128
1129 int iRet = E_ERROR;
1130 RowEntity rowEntity;
1131 iRet = resultSet->GetRow(rowEntity);
1132 EXPECT_EQ(E_OK, iRet);
1133
1134 std::string data1Value = rowEntity.Get("data1");
1135 EXPECT_EQ("hello", data1Value);
1136
1137 std::string data1ValueByIndex = rowEntity.Get(0);
1138 EXPECT_EQ("hello", data1ValueByIndex);
1139 }
1140
1141 /* *
1142 * @tc.name: Sqlite_Shared_Result_Set_021
1143 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for PrepareStep, if len(qrySql) is less than 3
1144 * @tc.type: FUNC
1145 */
1146 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_021, TestSize.Level1)
1147 {
1148 GenerateDefaultTable();
1149 std::vector<std::string> selectionArgs;
1150 std::shared_ptr<AbsResultSet> resultSet = RdbSqliteSharedResultSetTest::store->QuerySql("SE", selectionArgs);
1151 EXPECT_NE(resultSet, nullptr);
1152
1153 std::vector<std::string> columnNames;
1154 int ret = resultSet->GetAllColumnNames(columnNames);
1155 EXPECT_EQ(E_INVALID_ARGS, ret);
1156 resultSet->Close();
1157 }
1158
1159 /* *
1160 * @tc.name: Sqlite_Shared_Result_Set_022
1161 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for PrepareStep, if qrySql is invalid
1162 * @tc.type: FUNC
1163 */
1164 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_022, TestSize.Level1)
1165 {
1166 GenerateDefaultTable();
1167 std::vector<std::string> selectionArgs;
1168 std::shared_ptr<AbsResultSet> resultSet =
1169 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT FROM", selectionArgs);
1170 EXPECT_NE(resultSet, nullptr);
1171
1172 std::vector<std::string> columnNames;
1173 int ret = resultSet->GetAllColumnNames(columnNames);
1174 EXPECT_EQ(E_SQLITE_ERROR, ret);
1175 resultSet->Close();
1176 }
1177
1178 /* *
1179 * @tc.name: Sqlite_Shared_Result_Set_023
1180 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for GetAllColumnNames, if resultSet is closed
1181 * @tc.type: FUNC
1182 */
1183 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_023, TestSize.Level1)
1184 {
1185 GenerateDefaultTable();
1186 std::vector<std::string> selectionArgs;
1187 std::shared_ptr<AbsResultSet> resultSet =
1188 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1189 EXPECT_NE(resultSet, nullptr);
1190
1191 resultSet->Close();
1192
1193 std::vector<std::string> columnNames;
1194 int ret = resultSet->GetAllColumnNames(columnNames);
1195 EXPECT_EQ(E_ALREADY_CLOSED, ret);
1196 }
1197
1198 /* *
1199 * @tc.name: Sqlite_Shared_Result_Set_024
1200 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for GetRowCount, if resultSet is closed
1201 * @tc.type: FUNC
1202 */
1203 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_024, TestSize.Level1)
1204 {
1205 GenerateDefaultTable();
1206 std::vector<std::string> selectionArgs;
1207 std::shared_ptr<AbsResultSet> resultSet =
1208 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1209 EXPECT_NE(resultSet, nullptr);
1210
1211 resultSet->Close();
1212
1213 int count = 0;
1214 int ret = resultSet->GetRowCount(count);
1215 EXPECT_EQ(E_ALREADY_CLOSED, ret);
1216 }
1217
1218 /* *
1219 * @tc.name: Sqlite_Shared_Result_Set_025
1220 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for GoToRow, if position is less than 0
1221 * @tc.type: FUNC
1222 */
1223 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_025, TestSize.Level1)
1224 {
1225 GenerateDefaultTable();
1226 std::vector<std::string> selectionArgs;
1227 std::shared_ptr<AbsResultSet> resultSet =
1228 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1229 EXPECT_NE(resultSet, nullptr);
1230
1231 int ret = resultSet->GoToRow(-10);
1232 EXPECT_EQ(E_ROW_OUT_RANGE, ret);
1233 resultSet->Close();
1234 }
1235
1236 /* *
1237 * @tc.name: Sqlite_Shared_Result_Set_026
1238 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for GetBlob, if position is less than 0
1239 * @tc.type: FUNC
1240 */
1241 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_026, TestSize.Level1)
1242 {
1243 GenerateDefaultTable();
1244 std::vector<std::string> selectionArgs;
1245 std::shared_ptr<AbsResultSet> resultSet =
1246 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1247 EXPECT_NE(resultSet, nullptr);
1248
1249 resultSet->GoToFirstRow();
1250
1251 std::vector<uint8_t> blob;
1252 int ret = resultSet->GetBlob(-10, blob);
1253 EXPECT_EQ(E_COLUMN_OUT_RANGE, ret);
1254 resultSet->Close();
1255 }
1256
1257 /* *
1258 * @tc.name: Sqlite_Shared_Result_Set_027
1259 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for GetAsset, if col is less than 0
1260 * @tc.type: FUNC
1261 */
1262 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_027, TestSize.Level1)
1263 {
1264 GenerateDefaultTable();
1265 std::vector<std::string> selectionArgs;
1266 std::shared_ptr<AbsResultSet> resultSet =
1267 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1268 EXPECT_NE(resultSet, nullptr);
1269
1270 resultSet->GoToFirstRow();
1271
1272 ValueObject::Asset value;
1273 int ret = resultSet->GetAsset(-10, value);
1274 EXPECT_EQ(E_COLUMN_OUT_RANGE, ret);
1275 resultSet->Close();
1276 }
1277
1278 /* *
1279 * @tc.name: Sqlite_Shared_Result_Set_028
1280 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for GetAssets, if col is less than 0
1281 * @tc.type: FUNC
1282 */
1283 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_028, TestSize.Level1)
1284 {
1285 GenerateDefaultTable();
1286 std::vector<std::string> selectionArgs;
1287 std::shared_ptr<AbsResultSet> resultSet =
1288 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1289 EXPECT_NE(resultSet, nullptr);
1290
1291 resultSet->GoToFirstRow();
1292
1293 ValueObject::Assets value;
1294 int ret = resultSet->GetAssets(-10, value);
1295 EXPECT_EQ(E_COLUMN_OUT_RANGE, ret);
1296 resultSet->Close();
1297 }
1298
1299 /* *
1300 * @tc.name: Sqlite_Shared_Result_Set_029
1301 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for GetSize, if columnIndex is less than 0
1302 * @tc.type: FUNC
1303 */
1304 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_029, TestSize.Level1)
1305 {
1306 GenerateDefaultTable();
1307 std::vector<std::string> selectionArgs;
1308 std::shared_ptr<AbsResultSet> resultSet =
1309 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1310 EXPECT_NE(resultSet, nullptr);
1311
1312 resultSet->GoToFirstRow();
1313
1314 size_t size;
1315 int ret = resultSet->GetSize(-10, size);
1316 EXPECT_EQ(E_COLUMN_OUT_RANGE, ret);
1317 resultSet->Close();
1318 }
1319
1320 /* *
1321 * @tc.name: Sqlite_Shared_Result_Set_030
1322 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for IsColumnNull, if columnIndex is less than 0
1323 * @tc.type: FUNC
1324 */
1325 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_030, TestSize.Level1)
1326 {
1327 GenerateDefaultTable();
1328 std::vector<std::string> selectionArgs;
1329 std::shared_ptr<AbsResultSet> resultSet =
1330 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1331 EXPECT_NE(resultSet, nullptr);
1332
1333 resultSet->GoToFirstRow();
1334
1335 bool isNUll;
1336 int ret = resultSet->IsColumnNull(-10, isNUll);
1337 EXPECT_EQ(E_COLUMN_OUT_RANGE, ret);
1338 resultSet->Close();
1339 }
1340
1341 /* *
1342 * @tc.name: Sqlite_Shared_Result_Set_031
1343 * @tc.desc: Abnormal testcase of SqliteSharedResultSet for Close, if close resultSet twice
1344 * @tc.type: FUNC
1345 */
1346 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_031, TestSize.Level2)
1347 {
1348 GenerateDefaultTable();
1349 std::vector<std::string> selectionArgs;
1350 std::shared_ptr<AbsResultSet> resultSet =
1351 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1352 EXPECT_NE(resultSet, nullptr);
1353
1354 EXPECT_EQ(E_OK, resultSet->Close());
1355 EXPECT_EQ(true, resultSet->IsClosed());
1356 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToLastRow());
1357
1358 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToPreviousRow());
1359
1360 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToFirstRow());
1361
1362 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToRow(1));
1363
1364 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToPreviousRow());
1365
1366 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToFirstRow());
1367
1368 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToRow(1));
1369
1370 bool isExpectResult = true;
1371 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->IsAtLastRow(isExpectResult));
1372 EXPECT_NE(false, isExpectResult);
1373
1374 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->IsEnded(isExpectResult));
1375 EXPECT_NE(false, isExpectResult);
1376
1377 int columnCount;
1378 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetColumnCount(columnCount));
1379
1380 std::string columnName;
1381 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetColumnName(1, columnName));
1382
1383 EXPECT_EQ(E_OK, resultSet->Close());
1384 }
1385
1386 /* *
1387 * @tc.name: Sqlite_Shared_Result_Set_032
1388 * @tc.desc: Normal testcase of SqliteSharedResultSet for GetRow
1389 * @tc.type: FUNC
1390 */
1391 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_032, TestSize.Level1)
1392 {
1393 GenerateAssetsTable();
1394 std::vector<std::string> selectionArgs;
1395 std::shared_ptr<AbsResultSet> resultSet =
1396 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1397 EXPECT_NE(resultSet, nullptr);
1398
1399 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1400
1401 int iRet = E_ERROR;
1402 RowEntity rowEntity;
1403 iRet = resultSet->GetRow(rowEntity);
1404 EXPECT_EQ(E_OK, iRet);
1405 }
1406
1407 /* *
1408 * @tc.name: Sqlite_Shared_Result_Set_033
1409 * @tc.desc: Normal testcase of SqliteSharedResultSet for GoToNestRow when some rows are close to 2M in size
1410 * @tc.type: FUNC
1411 */
1412 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_033, TestSize.Level1)
1413 {
1414 constexpr int INSERT_NUM = 10;
1415 std::vector<ValuesBucket> vbs;
1416 vbs.reserve(10);
1417 ValuesBucket vb;
1418 for (int i = 0; i < INSERT_NUM; i++) {
1419 vb.PutInt("id", i);
1420 // this row must exclusive shared memory
1421 if (i == 4) {
1422 vb.PutString("data1", std::string(3 * 512 * 1024 + 5000, 'a'));
1423 }
1424 vb.PutString("data1", std::string(512 * 1024 - 2000, 'b'));
1425 vbs.push_back(std::move(vb));
1426 }
1427 int64_t insertNum = 0;
1428 EXPECT_EQ(E_OK, store->BatchInsert(insertNum, "test", vbs));
1429 EXPECT_EQ(insertNum, INSERT_NUM);
1430 std::vector<std::string> selectionArgs;
1431 std::shared_ptr<AbsResultSet> resultSet =
1432 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test ORDER BY id ASC", selectionArgs);
1433 ASSERT_NE(resultSet, nullptr);
1434 for (int i = 0; i < INSERT_NUM; i++) {
1435 ASSERT_EQ(E_OK, resultSet->GoToRow(i)) << "Current position:" << i;
1436 int position = -1;
1437 ASSERT_EQ(E_OK, resultSet->GetRowIndex(position)) << "Current position:" << i;
1438 EXPECT_EQ(position, i);
1439 int count = -1;
1440 ASSERT_EQ(E_OK, resultSet->GetRowCount(count)) << "Current position:" << i;
1441 EXPECT_EQ(count, INSERT_NUM) << "Current position:" << i;
1442 int columnIndex = 0;
1443 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("id", columnIndex)) << "Current position:" << i;
1444 int id;
1445 EXPECT_EQ(E_OK, resultSet->GetInt(columnIndex, id)) << "Current position:" << i;
1446 EXPECT_EQ(id, i);
1447
1448 ASSERT_EQ(E_OK, resultSet->GetColumnIndex("data1", columnIndex)) << "Current position:" << i;
1449 std::string value;
1450 EXPECT_EQ(E_OK, resultSet->GetString(columnIndex, value)) << "Current position:" << i;
1451 if (i == 4) {
1452 EXPECT_EQ(value.size(), 3 * 512 * 1024 + 5000) << "Current position:" << i;
1453 } else {
1454 EXPECT_EQ(value.size(), 512 * 1024 - 2000) << "Current position:" << i;
1455 }
1456 }
1457 }
1458
1459 /* *
1460 * @tc.name: Sqlite_Shared_Result_Set_034
1461 * @tc.desc: Normal testcase of SqliteSharedResultSet for GoTo when moving back and forth
1462 * @tc.type: FUNC
1463 */
1464 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_034, TestSize.Level1)
1465 {
1466 constexpr int INSERT_NUM = 20;
1467 std::vector<ValuesBucket> vbs;
1468 vbs.reserve(10);
1469 ValuesBucket vb;
1470 for (int i = 0; i < INSERT_NUM; i++) {
1471 vb.PutInt("id", i);
1472 vb.PutString("data1", std::string(i * 100 * 1024, 'a'));
1473 vbs.push_back(std::move(vb));
1474 }
1475 int64_t insertNum = 0;
1476 EXPECT_EQ(E_OK, store->BatchInsert(insertNum, "test", vbs));
1477 EXPECT_EQ(insertNum, INSERT_NUM);
1478 std::vector<std::string> selectionArgs;
1479 std::shared_ptr<AbsResultSet> resultSet =
1480 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test ORDER BY id ASC", selectionArgs);
1481 ASSERT_NE(resultSet, nullptr);
1482 int position = -1;
1483 int count = -1;
1484 int columnIndex = 0;
1485 int id;
1486 int target = INSERT_NUM / 2;
1487 std::string value;
1488 ASSERT_EQ(E_OK, resultSet->GoToRow(target));
1489 ASSERT_EQ(E_OK, resultSet->GetRowIndex(position));
1490 ASSERT_EQ(target, position);
1491 for (int i = 1; i < INSERT_NUM; i++) {
1492 target = INSERT_NUM - position - i & 0x1;
1493 ASSERT_EQ(E_OK, resultSet->GoToRow(target)) << "Current position:" << position << ", go to:" << target;
1494 ASSERT_EQ(E_OK, resultSet->GetRowIndex(position));
1495 ASSERT_EQ(target, position);
1496 ASSERT_EQ(E_OK, resultSet->GetRowCount(count)) << "Current position:" << position;
1497 EXPECT_EQ(count, INSERT_NUM) << "Current position:" << position;
1498 EXPECT_EQ(E_OK, resultSet->GetColumnIndex("id", columnIndex)) << "Current position:" << position;
1499 EXPECT_EQ(E_OK, resultSet->GetInt(columnIndex, id)) << "Current position:" << position;
1500 EXPECT_EQ(id, position);
1501 ASSERT_EQ(E_OK, resultSet->GetColumnIndex("data1", columnIndex)) << "Current position:" << i;
1502 EXPECT_EQ(E_OK, resultSet->GetString(columnIndex, value)) << "Current position:" << i;
1503 EXPECT_EQ(value.size(), position * 100 * 1024) << "Current position:" << i;
1504 }
1505 }
1506
1507 /* *
1508 * @tc.name: Sqlite_Shared_Result_Set_035
1509 * @tc.desc: normal testcase of SqliteSharedResultSet for qrySql is WITH
1510 * @tc.type: FUNC
1511 */
1512 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_035, TestSize.Level1)
1513 {
1514 GenerateDefaultTable();
1515 std::vector<std::string> selectionArgs;
1516 std::shared_ptr<AbsResultSet> resultSet =
1517 RdbSqliteSharedResultSetTest::store->QuerySql("WITH tem AS ( SELECT * FROM test) SELECT * FROM tem");
1518 EXPECT_NE(resultSet, nullptr);
1519
1520 std::vector<std::string> columnNames;
1521 int ret = resultSet->GetAllColumnNames(columnNames);
1522 EXPECT_EQ(E_OK, ret);
1523
1524 std::string colName = "";
1525 resultSet->GetColumnName(1, colName);
1526 EXPECT_EQ(colName, "data1");
1527 EXPECT_EQ(columnNames[1], colName);
1528
1529 resultSet->GetColumnName(2, colName);
1530 EXPECT_EQ(colName, "data2");
1531 EXPECT_EQ(columnNames[2], colName);
1532
1533 resultSet->GetColumnName(3, colName);
1534 EXPECT_EQ(colName, "data3");
1535 resultSet->GetColumnName(4, colName);
1536 EXPECT_EQ(colName, "data4");
1537
1538 resultSet->Close();
1539 }
1540
1541 /* *
1542 * @tc.name: Sqlite_Shared_Result_Set_036
1543 * @tc.desc: normal testcase of SqliteSharedResultSet for moveFirst
1544 * @tc.type: FUNC
1545 */
1546 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_036, TestSize.Level1)
1547 {
1548 std::vector<std::string> selectionArgs;
1549 std::shared_ptr<ResultSet> rstSet =
1550 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1551 EXPECT_NE(rstSet, nullptr);
1552
1553 int ret = rstSet->GoToFirstRow();
1554 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
1555 ret = rstSet->GoToLastRow();
1556 EXPECT_EQ(ret, E_ERROR);
1557 }
1558
1559 /* *
1560 * @tc.name: Sqlite_Shared_Result_Set_037
1561 * @tc.desc: normal testcase of SqliteSharedResultSet for PRAGMA user_version
1562 * @tc.type: FUNC
1563 */
1564 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_037, TestSize.Level1)
1565 {
1566 // 2 is used to set the store version
1567 int ret = store->ExecuteSql("PRAGMA user_version = 2");
1568 EXPECT_EQ(ret, E_OK);
1569 std::shared_ptr<ResultSet> resultSet = store->QuerySql("PRAGMA user_version");
1570
1571 int64_t longValue;
1572 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1573 EXPECT_EQ(E_OK, resultSet->GetLong(0, longValue));
1574 EXPECT_EQ(2, longValue);
1575
1576 resultSet->Close();
1577 }
1578
1579 /* *
1580 * @tc.name: Sqlite_Shared_Result_Set_038
1581 * @tc.desc: normal testcase of SqliteSharedResultSet for PRAGMA table_info
1582 * @tc.type: FUNC
1583 */
1584 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_038, TestSize.Level1)
1585 {
1586 int ret = store->ExecuteSql("PRAGMA table_info(test)");
1587 EXPECT_EQ(ret, E_OK);
1588 std::shared_ptr<ResultSet> resultSet = store->QuerySql("PRAGMA table_info(test)");
1589
1590 std::string strValue;
1591 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1592 EXPECT_EQ(E_OK, resultSet->GetString(1, strValue));
1593 EXPECT_EQ("id", strValue);
1594 EXPECT_EQ(E_OK, resultSet->GetString(2, strValue));
1595 EXPECT_EQ("INTEGER", strValue);
1596
1597 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
1598 EXPECT_EQ(E_OK, resultSet->GetString(1, strValue));
1599 EXPECT_EQ("data1", strValue);
1600 EXPECT_EQ(E_OK, resultSet->GetString(2, strValue));
1601 EXPECT_EQ("TEXT", strValue);
1602
1603 resultSet->Close();
1604 }
1605
1606 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_039, TestSize.Level1)
1607 {
1608 GenerateDefaultTable();
1609 int64_t id;
1610 ValuesBucket values;
1611 values.PutNull("data1");
1612 values.PutNull("data2");
1613 values.PutNull("data3");
1614 values.PutNull("data4");
1615 values.PutNull("data5");
1616 values.PutNull("data6");
1617 values.PutNull("data7");
1618 values.PutNull("data8");
1619 store->Insert(id, "test", values);
1620 std::vector<std::string> selectionArgs;
1621 std::shared_ptr<ResultSet> rstSet =
1622 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
1623 EXPECT_NE(rstSet, nullptr);
1624
1625 ColumnType colType;
1626 int ret = rstSet->GetColumnType(0, colType);
1627 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
1628 int retF = rstSet->GoTo(4);
1629 EXPECT_EQ(retF, E_OK);
1630
1631 rstSet->GetColumnType(0, colType);
1632 EXPECT_EQ(colType, ColumnType::TYPE_INTEGER);
1633 rstSet->GetColumnType(1, colType);
1634 EXPECT_EQ(colType, ColumnType::TYPE_NULL);
1635 rstSet->GetColumnType(2, colType);
1636 EXPECT_EQ(colType, ColumnType::TYPE_NULL);
1637 rstSet->GetColumnType(3, colType);
1638 EXPECT_EQ(colType, ColumnType::TYPE_NULL);
1639 rstSet->GetColumnType(4, colType);
1640 EXPECT_EQ(colType, ColumnType::TYPE_NULL);
1641 rstSet->GetColumnType(5, colType);
1642 EXPECT_EQ(colType, ColumnType::TYPE_NULL);
1643 rstSet->GetColumnType(6, colType);
1644 EXPECT_EQ(colType, ColumnType::TYPE_NULL);
1645 rstSet->GetColumnType(7, colType);
1646 EXPECT_EQ(colType, ColumnType::TYPE_NULL);
1647 rstSet->GetColumnType(8, colType);
1648 EXPECT_EQ(colType, ColumnType::TYPE_NULL);
1649 rstSet->Close();
1650 }
1651
1652 /**
1653 * @tc.name: Sqlite_Shared_Result_Set_003
1654 * @tc.desc: Abnormal testCase of PrepareStep
1655 * @tc.type: FUNC
1656 */
1657 HWTEST_F(RdbSqliteSharedResultSetTest, SqliteSharedResultSet_003, TestSize.Level2)
1658 {
1659 ValueObjects values = {};
1660 Time start = std::chrono::steady_clock::now();
1661 auto sqliteSharedRst = std::make_shared<SqliteSharedResultSet>(
1662 start, nullptr, SqliteSharedOpenCallback::CREATE_TABLE_TEST, values, DATABASE_NAME);
1663 auto res = sqliteSharedRst->PrepareStep();
1664 ASSERT_EQ(res.first, nullptr);
1665 EXPECT_EQ(res.second, E_ALREADY_CLOSED);
1666 }
1667
1668 /**
1669 * @tc.name: Sqlite_Shared_Result_Set_004
1670 * @tc.desc: Abnormal testCase of GetColumnNames
1671 * @tc.type: FUNC
1672 */
1673 HWTEST_F(RdbSqliteSharedResultSetTest, SqliteSharedResultSet_004, TestSize.Level2)
1674 {
1675 ValueObjects values = {};
1676 Time start = std::chrono::steady_clock::now();
1677 auto sqliteSharedRst = std::make_shared<SqliteSharedResultSet>(
1678 start, nullptr, SqliteSharedOpenCallback::CREATE_TABLE_TEST, values, DATABASE_NAME);
1679 auto res = sqliteSharedRst->GetColumnNames();
1680 EXPECT_EQ(res.first, E_ALREADY_CLOSED);
1681 EXPECT_TRUE(res.second.empty());
1682 }
1683
1684 /**
1685 * @tc.name: Sqlite_Shared_Result_Set_005
1686 * @tc.desc: Abnormal testCase of OnGo
1687 * @tc.type: FUNC
1688 */
1689 HWTEST_F(RdbSqliteSharedResultSetTest, SqliteSharedResultSet_005, TestSize.Level2)
1690 {
1691 ValueObjects values = {};
1692 Time start = std::chrono::steady_clock::now();
1693 auto sqliteSharedRst = std::make_shared<SqliteSharedResultSet>(
1694 start, nullptr, SqliteSharedOpenCallback::CREATE_TABLE_TEST, values, DATABASE_NAME);
1695 auto res = sqliteSharedRst->OnGo(0, 0);
1696 EXPECT_EQ(res, E_ALREADY_CLOSED);
1697 }