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 #include <string>
18
19 #include "sqlite_shared_result_set.h"
20 #include "shared_block.h"
21 #include "logger.h"
22 #include "common.h"
23 #include "rdb_errno.h"
24 #include "rdb_helper.h"
25 #include "rdb_open_callback.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::NativeRdb;
29 class RdbSqliteSharedResultSetTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 void GenerateDefaultTable();
36
37 static const std::string DATABASE_NAME;
38 static std::shared_ptr<RdbStore> store;
39 static const int E_SQLITE_ERROR;
40 };
41
42 const std::string RdbSqliteSharedResultSetTest::DATABASE_NAME = RDB_TEST_PATH + "shared_test.db";
43 std::shared_ptr<RdbStore> RdbSqliteSharedResultSetTest::store = nullptr;
44 const int RdbSqliteSharedResultSetTest::E_SQLITE_ERROR = -1;
45
46 class SqliteSharedOpenCallback : public RdbOpenCallback {
47 public:
48 int OnCreate(RdbStore &rdbStore) override;
49 int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override;
50 static const std::string CREATE_TABLE_TEST;
51 };
52
53 std::string const SqliteSharedOpenCallback::CREATE_TABLE_TEST =
54 "CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT,data2 INTEGER, data3 FLOAT, data4 BLOB);";
55
56
OnCreate(RdbStore & rdbStore)57 int SqliteSharedOpenCallback::OnCreate(RdbStore &rdbStore)
58 {
59 return rdbStore.ExecuteSql(CREATE_TABLE_TEST);
60 }
61
OnUpgrade(RdbStore & rdbStore,int oldVersion,int newVersion)62 int SqliteSharedOpenCallback::OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion)
63 {
64 return E_OK;
65 }
66
SetUpTestCase(void)67 void RdbSqliteSharedResultSetTest::SetUpTestCase(void)
68 {
69 RdbStoreConfig sqliteSharedRstConfig(RdbSqliteSharedResultSetTest::DATABASE_NAME);
70 SqliteSharedOpenCallback sqliteSharedRstHelper;
71 int errCode = E_OK;
72 RdbSqliteSharedResultSetTest::store =
73 RdbHelper::GetRdbStore(sqliteSharedRstConfig, 1, sqliteSharedRstHelper, errCode);
74 EXPECT_NE(RdbSqliteSharedResultSetTest::store, nullptr);
75 }
76
TearDownTestCase(void)77 void RdbSqliteSharedResultSetTest::TearDownTestCase(void)
78 {
79 RdbHelper::DeleteRdbStore(RdbSqliteSharedResultSetTest::DATABASE_NAME);
80 }
81
SetUp()82 void RdbSqliteSharedResultSetTest::SetUp()
83 {
84 store->ExecuteSql("DELETE FROM test");
85 }
86
TearDown()87 void RdbSqliteSharedResultSetTest::TearDown()
88 {}
89
GenerateDefaultTable()90 void RdbSqliteSharedResultSetTest::GenerateDefaultTable()
91 {
92 std::shared_ptr<RdbStore> &store = RdbSqliteSharedResultSetTest::store;
93
94 int64_t id;
95 ValuesBucket values;
96
97 values.PutInt("id", 1);
98 values.PutString("data1", std::string("hello"));
99 values.PutInt("data2", 10);
100 values.PutDouble("data3", 1.0);
101 values.PutBlob("data4", std::vector<uint8_t> { 66 });
102 store->Insert(id, "test", values);
103
104 values.Clear();
105 values.PutInt("id", 2);
106 values.PutString("data1", std::string("2"));
107 values.PutInt("data2", -5);
108 values.PutDouble("data3", 2.5);
109 values.PutBlob("data4", std::vector<uint8_t> {});
110 store->Insert(id, "test", values);
111
112 values.Clear();
113 values.PutInt("id", 3);
114 values.PutString("data1", std::string("hello world"));
115 values.PutInt("data2", 3);
116 values.PutDouble("data3", 1.8);
117 values.PutBlob("data4", std::vector<uint8_t> {});
118 store->Insert(id, "test", values);
119 }
120
121 /* *
122 * @tc.name: RdbStore_Delete_001
123 * @tc.desc: normal testcase of SqliteSharedResultSet for move
124 * @tc.type: FUNC
125 * @tc.require: AR000FKD4F
126 */
127 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_001, TestSize.Level1)
128 {
129 GenerateDefaultTable();
130 std::vector<std::string> selectionArgs;
131 std::unique_ptr<ResultSet> rstSet =
132 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
133 EXPECT_NE(rstSet, nullptr);
134
135 int ret = rstSet->GoToRow(1);
136 EXPECT_EQ(ret, E_OK);
137
138 int rowCnt = -1;
139 ret = rstSet->GetRowCount(rowCnt);
140 EXPECT_EQ(rowCnt, 3);
141
142 std::string colName = "";
143 rstSet->GetColumnName(1, colName);
144 EXPECT_EQ(colName, "data1");
145
146 rstSet->GetColumnName(2, colName);
147 EXPECT_EQ(colName, "data2");
148
149 rstSet->GetColumnName(3, colName);
150 EXPECT_EQ(colName, "data3");
151
152 rstSet->GetColumnName(4, colName);
153 EXPECT_EQ(colName, "data4");
154
155 std::string valueStr = "";
156 rstSet->GetString(0, valueStr);
157 EXPECT_EQ(valueStr, "2");
158
159 rstSet->GetString(1, valueStr);
160 EXPECT_EQ(valueStr, "2");
161
162 int64_t valuelg = 0;
163 rstSet->GetLong(2, valuelg);
164 EXPECT_EQ(valuelg, -5);
165
166 double valueDb = 0.0;
167 rstSet->GetDouble(3, valueDb);
168 EXPECT_EQ(valueDb, 2.5);
169
170 std::vector<uint8_t> blob;
171 rstSet->GetBlob(4, blob);
172 int sz = blob.size();
173 EXPECT_EQ(sz, 0);
174
175 rstSet->GoTo(1);
176 rstSet->GetString(0, valueStr);
177 EXPECT_EQ(valueStr, "3");
178
179 rstSet->GetString(1, valueStr);
180 EXPECT_EQ(valueStr, "hello world");
181
182 rstSet->GetLong(2, valuelg);
183 EXPECT_EQ(valuelg, 3);
184
185 rstSet->GetDouble(3, valueDb);
186 EXPECT_EQ(valueDb, 1.8);
187
188 rstSet->GetBlob(4, blob);
189 sz = blob.size();
190 EXPECT_EQ(sz, 0);
191
192 bool isNull = false;
193 rstSet->IsColumnNull(4, isNull);
194 EXPECT_EQ(isNull, true);
195
196 ret = -1;
197 ret = rstSet->GoToPreviousRow();
198 EXPECT_EQ(ret, E_OK);
199 ret = -1;
200 ret = rstSet->GoToPreviousRow();
201 EXPECT_EQ(ret, E_OK);
202
203 rstSet->GetString(0, valueStr);
204 EXPECT_EQ(valueStr, "1");
205
206 rstSet->GetString(1, valueStr);
207 EXPECT_EQ(valueStr, "hello");
208
209 rstSet->GetLong(2, valuelg);
210 EXPECT_EQ(valuelg, 10);
211
212 rstSet->GetDouble(3, valueDb);
213 EXPECT_EQ(valueDb, 1.0);
214
215 rstSet->Close();
216 bool isClosedFlag = rstSet->IsClosed();
217 EXPECT_EQ(isClosedFlag, true);
218 }
219
220 /* *
221 * @tc.name: Sqlite_Shared_Result_Set_002
222 * @tc.desc: normal testcase of SqliteSharedResultSet for goToNextRow
223 * @tc.type: FUNC
224 * @tc.require: AR000FKD4F
225 */
226 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_002, TestSize.Level1)
227 {
228 GenerateDefaultTable();
229 std::vector<std::string> selectionArgs;
230 std::unique_ptr<ResultSet> rstSet =
231 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
232 EXPECT_NE(rstSet, nullptr);
233
234 int pos = -2;
235 rstSet->GetRowIndex(pos);
236 EXPECT_EQ(pos, -1);
237 bool isStart = true;
238 rstSet->IsStarted(isStart);
239 EXPECT_EQ(isStart, false);
240 bool isAtFirstRow = true;
241 rstSet->IsAtFirstRow(isAtFirstRow);
242 EXPECT_EQ(isAtFirstRow, false);
243 bool isEnded = true;
244 rstSet->IsEnded(isEnded);
245 EXPECT_EQ(isEnded, false);
246
247 int retN1 = rstSet->GoToNextRow();
248 EXPECT_EQ(retN1, E_OK);
249 rstSet->GetRowIndex(pos);
250 EXPECT_EQ(pos, 0);
251 rstSet->IsStarted(isStart);
252 EXPECT_EQ(isStart, true);
253 rstSet->IsAtFirstRow(isAtFirstRow);
254 EXPECT_EQ(isAtFirstRow, true);
255 isEnded = true;
256 rstSet->IsEnded(isEnded);
257 EXPECT_EQ(isEnded, false);
258
259 int retN2 = rstSet->GoToNextRow();
260 EXPECT_EQ(retN2, E_OK);
261 rstSet->GetRowIndex(pos);
262 EXPECT_EQ(pos, 1);
263 isStart = false;
264 rstSet->IsStarted(isStart);
265 EXPECT_EQ(isStart, true);
266 isAtFirstRow = true;
267 rstSet->IsAtFirstRow(isAtFirstRow);
268 EXPECT_EQ(isAtFirstRow, false);
269 isEnded = true;
270 rstSet->IsEnded(isEnded);
271 EXPECT_EQ(isEnded, false);
272
273 int retN3 = rstSet->GoToNextRow();
274 EXPECT_EQ(retN3, E_OK);
275 rstSet->GetRowIndex(pos);
276 EXPECT_EQ(pos, 2);
277 isStart = false;
278 rstSet->IsStarted(isStart);
279 EXPECT_EQ(isStart, true);
280 isAtFirstRow = true;
281 rstSet->IsAtFirstRow(isAtFirstRow);
282 EXPECT_EQ(isAtFirstRow, false);
283 bool isAtLastRow = false;
284 rstSet->IsAtLastRow(isAtLastRow);
285 EXPECT_EQ(isAtLastRow, true);
286
287 int retN = rstSet->GoToNextRow();
288 EXPECT_EQ(retN, E_ERROR);
289 rstSet->GetRowIndex(pos);
290 EXPECT_EQ(pos, 3);
291 isStart = false;
292 rstSet->IsStarted(isStart);
293 EXPECT_EQ(isStart, true);
294 isAtFirstRow = true;
295 rstSet->IsAtFirstRow(isAtFirstRow);
296 EXPECT_EQ(isAtFirstRow, false);
297 isEnded = false;
298 rstSet->IsEnded(isEnded);
299 EXPECT_EQ(isEnded, true);
300
301 rstSet->Close();
302 bool isClosedFlag = rstSet->IsClosed();
303 EXPECT_EQ(isClosedFlag, true);
304 }
305
306 /* *
307 * @tc.name: Sqlite_Shared_Result_Set_003
308 * @tc.desc: normal testcase of SqliteSharedResultSet for moveFirst
309 * @tc.type: FUNC
310 * @tc.require: AR000FKD4F
311 */
312 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_003, TestSize.Level1)
313 {
314 GenerateDefaultTable();
315 std::vector<std::string> selectionArgs;
316 std::unique_ptr<ResultSet> rstSet =
317 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
318 EXPECT_NE(rstSet, nullptr);
319
320 int retF = rstSet->GoToFirstRow();
321 EXPECT_EQ(retF, E_OK);
322 int index = -1;
323 rstSet->GetRowIndex(index);
324 EXPECT_EQ(index, 0);
325 bool isAtFirstRow = false;
326 rstSet->IsAtFirstRow(isAtFirstRow);
327 EXPECT_EQ(isAtFirstRow, true);
328 bool isStd = false;
329 rstSet->IsStarted(isStd);
330 EXPECT_EQ(isStd, true);
331
332 int retN = rstSet->GoToNextRow();
333 EXPECT_EQ(retN, E_OK);
334 rstSet->GetRowIndex(index);
335 EXPECT_EQ(index, 1);
336 isAtFirstRow = true;
337 rstSet->IsAtFirstRow(isAtFirstRow);
338 EXPECT_EQ(isAtFirstRow, false);
339 isStd = false;
340 rstSet->IsStarted(isStd);
341 EXPECT_EQ(isStd, true);
342
343 int retGf = rstSet->GoToFirstRow();
344 EXPECT_EQ(retGf, E_OK);
345 rstSet->GetRowIndex(index);
346 EXPECT_EQ(index, 0);
347 isAtFirstRow = false;
348 rstSet->IsAtFirstRow(isAtFirstRow);
349 EXPECT_EQ(isAtFirstRow, true);
350 isStd = false;
351 rstSet->IsStarted(isStd);
352 EXPECT_EQ(isStd, true);
353
354 rstSet->Close();
355 bool isClosedFlag = rstSet->IsClosed();
356 EXPECT_EQ(isClosedFlag, true);
357 }
358
359 /* *
360 * @tc.name: Sqlite_Shared_Result_Set_004
361 * @tc.desc: normal testcase of SqliteSharedResultSet for getInt
362 * @tc.type: FUNC
363 * @tc.require: AR000FKD4F
364 */
365 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_004, TestSize.Level1)
366 {
367 GenerateDefaultTable();
368 std::vector<std::string> selectionArgs;
369 std::unique_ptr<ResultSet> rstSet =
370 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
371 EXPECT_NE(rstSet, nullptr);
372
373 int64_t valueInt = 0;
374 int ret = rstSet->GetLong(0, valueInt);
375 EXPECT_EQ(ret, E_INVALID_STATEMENT);
376
377 int retF = rstSet->GoToFirstRow();
378 EXPECT_EQ(retF, E_OK);
379 rstSet->GetLong(0, valueInt);
380 EXPECT_EQ(valueInt, 1);
381 rstSet->GetLong(2, valueInt);
382 EXPECT_EQ(valueInt, 10);
383 rstSet->GetLong(3, valueInt);
384 EXPECT_EQ(valueInt, 1);
385
386 int retN = rstSet->GoToNextRow();
387 EXPECT_EQ(retN, E_OK);
388 rstSet->GetLong(0, valueInt);
389 EXPECT_EQ(valueInt, 2);
390 valueInt = 0;
391 rstSet->GetLong(0, valueInt);
392 EXPECT_EQ(valueInt, 2);
393 valueInt = 0;
394 rstSet->GetLong(1, valueInt);
395 EXPECT_EQ(valueInt, 2);
396
397 rstSet->Close();
398 bool isClosedFlag = rstSet->IsClosed();
399 EXPECT_EQ(isClosedFlag, true);
400 }
401
402 /* *
403 * @tc.name: Sqlite_Shared_Result_Set_005
404 * @tc.desc: normal testcase of SqliteSharedResultSet for getString
405 * @tc.type: FUNC
406 * @tc.require: AR000FKD4F
407 */
408
409 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_005, TestSize.Level1)
410 {
411 GenerateDefaultTable();
412 std::vector<std::string> selectionArgs;
413 std::unique_ptr<ResultSet> rstSet =
414 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
415 EXPECT_NE(rstSet, nullptr);
416
417 std::string valueStr = "";
418 int ret1 = rstSet->GetString(0, valueStr);
419 EXPECT_EQ(ret1, E_INVALID_STATEMENT);
420
421 int retF = rstSet->GoToFirstRow();
422 EXPECT_EQ(retF, E_OK);
423 valueStr = "";
424 rstSet->GetString(1, valueStr);
425 EXPECT_EQ(valueStr, "hello");
426 rstSet->GetString(2, valueStr);
427 EXPECT_EQ(valueStr, "10");
428 rstSet->GetString(3, valueStr);
429 EXPECT_EQ(valueStr, "1");
430
431 int ret2 = rstSet->GetString(4, valueStr);
432 EXPECT_EQ(ret2, E_OK);
433
434 valueStr = "";
435 int colCnt = 0;
436 rstSet->GetColumnCount(colCnt);
437 int ret3 = rstSet->GetString(colCnt, valueStr);
438 EXPECT_EQ(ret3, E_INVALID_COLUMN_INDEX);
439
440 int retN = rstSet->GoToNextRow();
441 EXPECT_EQ(retN, E_OK);
442 rstSet->GetString(0, valueStr);
443 EXPECT_EQ(valueStr, "2");
444 valueStr = "";
445 rstSet->GetString(1, valueStr);
446 EXPECT_EQ(valueStr, "2");
447 rstSet->GetString(2, valueStr);
448 EXPECT_EQ(valueStr, "-5");
449 rstSet->GetString(3, valueStr);
450 EXPECT_EQ(valueStr, "2.5");
451
452 rstSet->Close();
453 bool isClosedFlag = rstSet->IsClosed();
454 EXPECT_EQ(isClosedFlag, true);
455 }
456
457 /* *
458 * @tc.name: Sqlite_Shared_Result_Set_006
459 * @tc.desc: normal testcase of SqliteSharedResultSet for getDouble
460 * @tc.type: FUNC
461 * @tc.require: AR000FKD4F
462 */
463 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_006, TestSize.Level1)
464 {
465 GenerateDefaultTable();
466 std::vector<std::string> selectionArgs;
467 std::unique_ptr<ResultSet> rstSet =
468 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
469 EXPECT_NE(rstSet, nullptr);
470
471 double valueDb = 0.0;
472 int ret = rstSet->GetDouble(0, valueDb);
473 EXPECT_EQ(ret, E_INVALID_STATEMENT);
474
475 int retF = rstSet->GoToFirstRow();
476 EXPECT_EQ(retF, E_OK);
477 rstSet->GetDouble(0, valueDb);
478 EXPECT_EQ(valueDb, 1.0);
479 std::string valueStr = "";
480 rstSet->GetString(1, valueStr);
481 EXPECT_EQ(valueStr, "hello");
482 rstSet->GetDouble(2, valueDb);
483 EXPECT_EQ(valueDb, 10.0);
484 rstSet->GetDouble(3, valueDb);
485 EXPECT_EQ(valueDb, 1.0);
486
487 int colCnt = 0;
488 rstSet->GetColumnCount(colCnt);
489 int ret1 = rstSet->GetDouble(colCnt, valueDb);
490 EXPECT_EQ(ret1, E_INVALID_COLUMN_INDEX);
491
492 int retN = rstSet->GoToNextRow();
493 EXPECT_EQ(retN, E_OK);
494 rstSet->GetDouble(0, valueDb);
495 EXPECT_EQ(valueDb, 2.0);
496 valueDb = 0.0;
497 rstSet->GetDouble(1, valueDb);
498 EXPECT_EQ(valueDb, 2.0);
499
500 rstSet->GetDouble(2, valueDb);
501 EXPECT_EQ(valueDb, -5.0);
502 rstSet->GetDouble(3, valueDb);
503 EXPECT_EQ(valueDb, 2.5);
504
505 rstSet->Close();
506 bool isClosedFlag = rstSet->IsClosed();
507 EXPECT_EQ(isClosedFlag, true);
508 }
509
510 /* *
511 * @tc.name: Sqlite_Shared_Result_Set_007
512 * @tc.desc: normal testcase of SqliteSharedResultSet for getBlob
513 * @tc.type: FUNC
514 * @tc.require: AR000FKD4F
515 */
516 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_007, TestSize.Level1)
517 {
518 GenerateDefaultTable();
519 std::vector<std::string> selectionArgs;
520 std::unique_ptr<ResultSet> rstSet =
521 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
522 EXPECT_NE(rstSet, nullptr);
523
524 int retF = rstSet->GoToFirstRow();
525 EXPECT_EQ(retF, E_OK);
526
527 std::vector<uint8_t> blobVec;
528 rstSet->GetBlob(4, blobVec);
529 EXPECT_EQ(blobVec[0], 66);
530
531 int retN = rstSet->GoToNextRow();
532 EXPECT_EQ(retN, E_OK);
533 blobVec.clear();
534 rstSet->GetBlob(4, blobVec);
535 int blobSz = blobVec.size();
536 EXPECT_EQ(blobSz, 0);
537
538 int retN1 = rstSet->GoToNextRow();
539 EXPECT_EQ(retN1, E_OK);
540 blobVec.clear();
541 rstSet->GetBlob(4, blobVec);
542 EXPECT_EQ(blobSz, 0);
543
544 rstSet->Close();
545 bool isClosedFlag = rstSet->IsClosed();
546 EXPECT_EQ(isClosedFlag, true);
547 }
548
549 /* *
550 * @tc.name: Sqlite_Shared_Result_Set_008
551 * @tc.desc: normal testcase of SqliteSharedResultSet for getColumnTypeForIndex
552 * @tc.type: FUNC
553 * @tc.require: AR000FKD4F
554 */
555
556 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_008, TestSize.Level1)
557 {
558 GenerateDefaultTable();
559 std::vector<std::string> selectionArgs;
560 std::unique_ptr<ResultSet> rstSet =
561 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
562 EXPECT_NE(rstSet, nullptr);
563
564 ColumnType colType;
565 int ret = rstSet->GetColumnType(0, colType);
566 EXPECT_EQ(ret, E_INVALID_STATEMENT);
567 int retF = rstSet->GoToFirstRow();
568 EXPECT_EQ(retF, E_OK);
569
570 rstSet->GetColumnType(0, colType);
571 EXPECT_EQ(colType, ColumnType::TYPE_INTEGER);
572
573 bool isColNull = true;
574 rstSet->IsColumnNull(0, isColNull);
575 EXPECT_EQ(isColNull, false);
576
577 rstSet->GetColumnType(1, colType);
578 EXPECT_EQ(colType, ColumnType::TYPE_STRING);
579
580 isColNull = true;
581 rstSet->IsColumnNull(0, isColNull);
582 EXPECT_EQ(isColNull, false);
583
584 rstSet->GetColumnType(2, colType);
585 EXPECT_EQ(colType, ColumnType::TYPE_INTEGER);
586 rstSet->GetColumnType(3, colType);
587 EXPECT_EQ(colType, ColumnType::TYPE_FLOAT);
588 rstSet->GetColumnType(4, colType);
589 EXPECT_EQ(colType, ColumnType::TYPE_BLOB);
590
591 int colCnt = 0;
592 rstSet->GetColumnCount(colCnt);
593 int ret1 = rstSet->GetColumnType(colCnt, colType);
594 EXPECT_EQ(ret1, E_INVALID_COLUMN_INDEX);
595
596 rstSet->Close();
597 bool isClosedFlag = rstSet->IsClosed();
598 EXPECT_EQ(isClosedFlag, true);
599 }
600
601 /* *
602 * @tc.name: Sqlite_Shared_Result_Set_009
603 * @tc.desc: normal testcase of SqliteSharedResultSet for getColumnIndexForName
604 * @tc.type: FUNC
605 * @tc.require: AR000FKD4F
606 */
607 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_009, TestSize.Level1)
608 {
609 GenerateDefaultTable();
610 std::vector<std::string> selectionArgs;
611 std::unique_ptr<ResultSet> rstSet =
612 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
613 EXPECT_NE(rstSet, nullptr);
614
615 int colIndex = 0;
616 rstSet->GetColumnIndex("data1", colIndex);
617 EXPECT_EQ(colIndex, 1);
618
619 rstSet->GetColumnIndex("data2", colIndex);
620 EXPECT_EQ(colIndex, 2);
621
622 rstSet->GetColumnIndex("data3", colIndex);
623 EXPECT_EQ(colIndex, 3);
624
625 rstSet->GetColumnIndex("data4", colIndex);
626 EXPECT_EQ(colIndex, 4);
627
628 rstSet->GetColumnIndex("datax", colIndex);
629 EXPECT_EQ(colIndex, -1);
630
631 rstSet->Close();
632 bool isClosedFlag = rstSet->IsClosed();
633 EXPECT_EQ(isClosedFlag, true);
634 }
635
636 /* *
637 * @tc.name: Sqlite_Shared_Result_Set_010
638 * @tc.desc: normal testcase of SqliteSharedResultSet for getColumnNameForIndex
639 * @tc.type: FUNC
640 * @tc.require: AR000FKD4F
641 */
642 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_010, TestSize.Level1)
643 {
644 GenerateDefaultTable();
645 std::vector<std::string> selectionArgs;
646 std::unique_ptr<ResultSet> rstSet =
647 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
648 EXPECT_NE(rstSet, nullptr);
649
650 std::vector<std::string> allColNamesVec;
651 rstSet->GetAllColumnNames(allColNamesVec);
652
653 std::string colName = "";
654 rstSet->GetColumnName(1, colName);
655 EXPECT_EQ(colName, "data1");
656 EXPECT_EQ(allColNamesVec[1], colName);
657
658 rstSet->GetColumnName(2, colName);
659 EXPECT_EQ(colName, "data2");
660 EXPECT_EQ(allColNamesVec[2], colName);
661
662 rstSet->GetColumnName(3, colName);
663 EXPECT_EQ(colName, "data3");
664 rstSet->GetColumnName(4, colName);
665 EXPECT_EQ(colName, "data4");
666
667 int colCnt = 0;
668 rstSet->GetColumnCount(colCnt);
669 int ret = rstSet->GetColumnName(colCnt, colName);
670 EXPECT_EQ(ret, E_INVALID_COLUMN_INDEX);
671
672 rstSet->Close();
673 bool isClosedFlag = rstSet->IsClosed();
674 EXPECT_EQ(isClosedFlag, true);
675 }
676
677 /* *
678 * @tc.name: Sqlite_Shared_Result_Set_011
679 * @tc.desc: normal testcase of SqliteSharedResultSet
680 * @tc.type: FUNC
681 * @tc.require: AR000FKD4F
682 */
683 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_011, TestSize.Level1)
684 {
685 GenerateDefaultTable();
686 std::vector<std::string> selectionArgs;
687 std::unique_ptr<ResultSet> rstSet =
688 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
689 EXPECT_NE(rstSet, nullptr);
690
691 int retF = rstSet->GoToFirstRow();
692 EXPECT_EQ(retF, E_OK);
693
694 bool isAtFrtRow = false;
695 rstSet->IsAtFirstRow(isAtFrtRow);
696 EXPECT_EQ(isAtFrtRow, true);
697
698 bool isStarted = false;
699 rstSet->IsStarted(isStarted);
700 EXPECT_EQ(isStarted, true);
701
702 int64_t valueInt = 0;
703 rstSet->GetLong(2, valueInt);
704 EXPECT_EQ(valueInt, 10);
705
706 rstSet->Close();
707 bool isClosedFlag = rstSet->IsClosed();
708 EXPECT_EQ(isClosedFlag, true);
709 }
710
711 /* *
712 * @tc.name: Sqlite_Shared_Result_Set_012
713 * @tc.desc: normal testcase of SqliteSharedResultSet for getLong
714 * @tc.type: FUNC
715 * @tc.require: AR000FKD4F
716 */
717 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_012, TestSize.Level1)
718 {
719 GenerateDefaultTable();
720 std::vector<std::string> selectionArgs;
721 std::unique_ptr<ResultSet> rstSet =
722 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
723 EXPECT_NE(rstSet, nullptr);
724
725 int64_t valueInt = 0;
726 int ret = rstSet->GetLong(0, valueInt);
727 EXPECT_EQ(ret, E_INVALID_STATEMENT);
728
729 int retF = rstSet->GoToFirstRow();
730 EXPECT_EQ(retF, E_OK);
731 rstSet->GetLong(0, valueInt);
732 EXPECT_EQ(valueInt, 1.0);
733 std::string valueStr = "";
734 rstSet->GetString(1, valueStr);
735 EXPECT_EQ(valueStr, "hello");
736 rstSet->GetLong(2, valueInt);
737 EXPECT_EQ(valueInt, 10.0);
738 rstSet->GetLong(3, valueInt);
739 EXPECT_EQ(valueInt, 1.0);
740
741 int colCnt = 0;
742 rstSet->GetColumnCount(colCnt);
743 int ret1 = rstSet->GetLong(colCnt, valueInt);
744 EXPECT_EQ(ret1, E_INVALID_COLUMN_INDEX);
745
746 int retN = rstSet->GoToNextRow();
747 EXPECT_EQ(retN, E_OK);
748 rstSet->GetLong(0, valueInt);
749 EXPECT_EQ(valueInt, 2.0);
750 valueInt = 0;
751 rstSet->GetLong(1, valueInt);
752 EXPECT_EQ(valueInt, 2.0);
753 rstSet->GetLong(2, valueInt);
754 EXPECT_EQ(valueInt, -5.0);
755
756 rstSet->Close();
757 bool isClosedFlag = rstSet->IsClosed();
758 EXPECT_EQ(isClosedFlag, true);
759 }
760
761 /* *
762 * @tc.name: Sqlite_Shared_Result_Set_013
763 * @tc.desc: normal testcase of SqliteSharedResultSet for fillBlock
764 * @tc.type: FUNC
765 * @tc.require: AR000FKD4F
766 */
767 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_013, TestSize.Level1)
768 {
769 GenerateDefaultTable();
770 std::vector<std::string> selectionArgs;
771 std::unique_ptr<ResultSet> rstSet =
772 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
773 EXPECT_NE(rstSet, nullptr);
774
775 SqliteSharedResultSet *pSqlSharedRstSet = static_cast<SqliteSharedResultSet *>(rstSet.get());
776 bool isBk = pSqlSharedRstSet->HasBlock();
777 EXPECT_EQ(isBk, true);
778
779 rstSet->Close();
780 bool isClosedFlag = rstSet->IsClosed();
781 EXPECT_EQ(isClosedFlag, true);
782 }
783 /* *
784 * @tc.name: Sqlite_Shared_Result_Set_014
785 * @tc.desc: normal testcase of SqliteSharedResultSet for getBlock
786 * @tc.type: FUNC
787 * @tc.require: AR000FKD4F
788 */
789 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_014, TestSize.Level1)
790 {
791 GenerateDefaultTable();
792 std::vector<std::string> selectionArgs;
793 std::unique_ptr<ResultSet> rstSet =
794 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
795 EXPECT_NE(rstSet, nullptr);
796
797 SqliteSharedResultSet *pSqlSharedRstSet = static_cast<SqliteSharedResultSet *>(rstSet.get());
798 bool isBk = pSqlSharedRstSet->HasBlock();
799 EXPECT_EQ(isBk, true);
800
801 int retF = rstSet->GoToFirstRow();
802 EXPECT_EQ(retF, E_OK);
803 OHOS::AppDataFwk::SharedBlock* pBk = pSqlSharedRstSet->GetBlock();
804 EXPECT_NE(pBk, nullptr);
805
806 std::string path = RdbSqliteSharedResultSetTest::store->GetPath();
807 std::string path1 = pBk->Name();
808
809 EXPECT_EQ(path, "/data/test/shared_test.db");
810 EXPECT_EQ(path1, "/data/test/shared_test.db");
811
812 rstSet->Close();
813 bool isClosedFlag = rstSet->IsClosed();
814 EXPECT_EQ(isClosedFlag, true);
815 }
816 /* *
817 * @tc.name: Sqlite_Shared_Result_Set_015
818 * @tc.desc: normal testcase of SqliteSharedResultSet for setBlock
819 * @tc.type: FUNC
820 * @tc.require: AR000FKD4F
821 */
822 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_015, TestSize.Level1)
823 {
824 GenerateDefaultTable();
825 std::vector<std::string> selectionArgs;
826 std::unique_ptr<ResultSet> rstSet =
827 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
828 EXPECT_NE(rstSet, nullptr);
829
830 SqliteSharedResultSet *pSqlSharedRstSet = static_cast<SqliteSharedResultSet *>(rstSet.get());
831 bool isBk = pSqlSharedRstSet->HasBlock();
832 EXPECT_EQ(isBk, true);
833
834 int retN = rstSet->GoToNextRow();
835 EXPECT_EQ(retN, E_OK);
836
837 std::string path = RdbSqliteSharedResultSetTest::store->GetPath();
838 OHOS::AppDataFwk::SharedBlock* pBk = pSqlSharedRstSet->GetBlock();
839 std::string path1 = pBk->Name();
840
841 EXPECT_EQ(path, "/data/test/shared_test.db");
842 EXPECT_EQ(path1, "/data/test/shared_test.db");
843
844 rstSet->Close();
845 bool isClosedFlag = rstSet->IsClosed();
846 EXPECT_EQ(isClosedFlag, true);
847 }
848
849 /* *
850 * @tc.name: Sqlite_Shared_Result_Set_016
851 * @tc.desc: normal testcase of SqliteSharedResultSet for setFillWindowForwardOnly
852 * @tc.type: FUNC
853 * @tc.require: AR000FKD4F
854 */
855 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_016, TestSize.Level1)
856 {
857 GenerateDefaultTable();
858 std::vector<std::string> selectionArgs;
859 std::unique_ptr<ResultSet> rstSet =
860 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
861 EXPECT_NE(rstSet, nullptr);
862
863 SqliteSharedResultSet *pSqlSharedRstSet = static_cast<SqliteSharedResultSet *>(rstSet.get());
864 bool isBk = pSqlSharedRstSet->HasBlock();
865 EXPECT_EQ(isBk, true);
866
867 pSqlSharedRstSet->PickFillBlockStartPosition(0, 0);
868 pSqlSharedRstSet->SetFillBlockForwardOnly(true);
869 pSqlSharedRstSet->GoToFirstRow();
870
871 OHOS::AppDataFwk::SharedBlock* pBk = pSqlSharedRstSet->GetBlock();
872 EXPECT_NE(pBk, nullptr);
873 std::string path = RdbSqliteSharedResultSetTest::store->GetPath();
874 std::string path1 = pBk->Name();
875
876 EXPECT_EQ(path, "/data/test/shared_test.db");
877 EXPECT_EQ(path1, "/data/test/shared_test.db");
878
879 int rowCnt = 0;
880 pSqlSharedRstSet->GetRowCount(rowCnt);
881 int rowCntBk = pBk->GetRowNum();
882
883 EXPECT_EQ(rowCnt, rowCntBk);
884
885 rstSet->Close();
886 bool isClosedFlag = rstSet->IsClosed();
887 EXPECT_EQ(isClosedFlag, true);
888 }
889
890 /* *
891 * @tc.name: Sqlite_Shared_Result_Set_017
892 * @tc.desc: normal testcase of SqliteSharedResultSet for setExtensions and getExtensions
893 * @tc.type: FUNC
894 * @tc.require: AR000FKD4F
895 */
896 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_017, TestSize.Level1)
897 {
898 GenerateDefaultTable();
899 std::vector<std::string> selectionArgs;
900 std::unique_ptr<ResultSet> rstSet =
901 RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test", selectionArgs);
902 EXPECT_NE(rstSet, nullptr);
903
904 int rowCnt = 0;
905 rstSet->GetRowCount(rowCnt);
906 EXPECT_EQ(rowCnt, 3);
907 int ret = rstSet->GoToLastRow();
908 EXPECT_EQ(ret, E_OK);
909 }
910