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