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 <climits>
19 #include <string>
20
21 #include "common.h"
22 #include "rdb_errno.h"
23 #include "rdb_helper.h"
24 #include "rdb_open_callback.h"
25 #include "sqlite_sql_builder.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::NativeRdb;
29 namespace OHOS {
30 namespace NativeRdb {
31 struct ResultSetData {
32 std::string strValue;
33 int iValue;
34 double dValue;
35 std::vector<uint8_t> blobValue;
36 };
37
38 class RdbStepResultSetTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 void GenerateDefaultTable();
45 void GenerateDefaultEmptyTable();
46 void CheckColumnType(std::shared_ptr<ResultSet> resultSet, int columnIndex, ColumnType type);
47 void CheckResultSetAttribute(
48 std::shared_ptr<ResultSet> resultSet, int pos, bool isStart, bool isAtFirstRow, bool isEnded);
49 void CheckResultSetData(int columnIndex, std::shared_ptr<ResultSet> resultSet, ResultSetData &rowData);
50
51 static const std::string DATABASE_NAME;
52 static std::shared_ptr<RdbStore> store;
53 static ResultSetData g_resultSetData[3];
54 };
55
56 const std::string RdbStepResultSetTest::DATABASE_NAME = RDB_TEST_PATH + "stepResultSet_test.db";
57 std::shared_ptr<RdbStore> RdbStepResultSetTest::store = nullptr;
58 ResultSetData RdbStepResultSetTest::g_resultSetData[3] = { { "2", -5, 2.5, std::vector<uint8_t>{} },
59 { "hello", 10, 1.0, std::vector<uint8_t>{ 66 } }, { "hello world", 3, 1.8, std::vector<uint8_t>{} } };
60
61 class RdbStepResultSetOpenCallback : public RdbOpenCallback {
62 public:
63 int OnCreate(RdbStore &store) override;
64 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
65 static const std::string CREATE_TABLE_TEST;
66 };
67
OnCreate(RdbStore & store)68 int RdbStepResultSetOpenCallback::OnCreate(RdbStore &store)
69 {
70 return E_OK;
71 }
72
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)73 int RdbStepResultSetOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
74 {
75 return E_OK;
76 }
77
SetUpTestCase(void)78 void RdbStepResultSetTest::SetUpTestCase(void)
79 {
80 int errCode = E_OK;
81 RdbHelper::DeleteRdbStore(DATABASE_NAME);
82 RdbStoreConfig config(RdbStepResultSetTest::DATABASE_NAME);
83 RdbStepResultSetOpenCallback helper;
84 RdbStepResultSetTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
85 EXPECT_NE(RdbStepResultSetTest::store, nullptr);
86 EXPECT_EQ(errCode, E_OK);
87 }
88
TearDownTestCase(void)89 void RdbStepResultSetTest::TearDownTestCase(void)
90 {
91 RdbHelper::DeleteRdbStore(RdbStepResultSetTest::DATABASE_NAME);
92 }
93
SetUp(void)94 void RdbStepResultSetTest::SetUp(void)
95 {
96 store->ExecuteSql("DELETE FROM test");
97 }
98
TearDown(void)99 void RdbStepResultSetTest::TearDown(void)
100 {
101 RdbHelper::ClearCache();
102 }
103
GenerateDefaultTable()104 void RdbStepResultSetTest::GenerateDefaultTable()
105 {
106 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
107 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
108 store->ExecuteSql(createTableSql);
109
110 std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
111
112 /* insert first entry data */
113 uint8_t uValue = 66;
114 std::vector<uint8_t> typeBlob;
115 typeBlob.push_back(uValue);
116 store->ExecuteSql(insertSql, std::vector<ValueObject>{ ValueObject(std::string("hello")), ValueObject((int)10),
117 ValueObject((double)1.0), ValueObject((std::vector<uint8_t>)typeBlob) });
118
119 /* insert second entry data */
120 typeBlob.clear();
121 store->ExecuteSql(insertSql, std::vector<ValueObject>{
122 ValueObject(std::string("2")), ValueObject((int)-5), ValueObject((double)2.5),
123 ValueObject() // set double value 2.5
124 });
125
126 /* insert third entry data */
127 store->ExecuteSql(insertSql, std::vector<ValueObject>{
128 ValueObject(std::string("hello world")), ValueObject((int)3),
129 ValueObject((double)1.8), ValueObject() // set int value 3, double 1.8
130 });
131 }
132
GenerateDefaultEmptyTable()133 void RdbStepResultSetTest::GenerateDefaultEmptyTable()
134 {
135 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
136 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
137 store->ExecuteSql(createTableSql);
138 }
139
CheckColumnType(std::shared_ptr<ResultSet> resultSet,int columnIndex,ColumnType type)140 void RdbStepResultSetTest::CheckColumnType(std::shared_ptr<ResultSet> resultSet, int columnIndex, ColumnType type)
141 {
142 ColumnType columnType;
143 int iRet = resultSet->GetColumnType(columnIndex, columnType);
144 EXPECT_EQ(E_OK, iRet);
145 EXPECT_EQ(columnType, type);
146 }
147
CheckResultSetAttribute(std::shared_ptr<ResultSet> resultSet,int pos,bool isStart,bool isAtFirstRow,bool isEnded)148 void RdbStepResultSetTest::CheckResultSetAttribute(
149 std::shared_ptr<ResultSet> resultSet, int pos, bool isStart, bool isAtFirstRow, bool isEnded)
150 {
151 int position = -1;
152 int iRet = resultSet->GetRowIndex(position);
153 EXPECT_EQ(E_OK, iRet);
154 EXPECT_EQ(pos, position);
155
156 bool bResultSet = !isStart;
157 iRet = resultSet->IsStarted(bResultSet);
158 EXPECT_EQ(E_OK, iRet);
159 EXPECT_EQ(isStart, bResultSet);
160
161 bResultSet = !isAtFirstRow;
162 iRet = resultSet->IsAtFirstRow(bResultSet);
163 EXPECT_EQ(E_OK, iRet);
164 EXPECT_EQ(isAtFirstRow, bResultSet);
165
166 bResultSet = !isEnded;
167 iRet = resultSet->IsEnded(bResultSet);
168 EXPECT_EQ(E_OK, iRet);
169 EXPECT_EQ(isEnded, bResultSet);
170 }
171
CheckResultSetData(int columnIndex,std::shared_ptr<ResultSet> resultSet,ResultSetData & resultSetData)172 void RdbStepResultSetTest::CheckResultSetData(
173 int columnIndex, std::shared_ptr<ResultSet> resultSet, ResultSetData &resultSetData)
174 {
175 std::string strValue;
176 int iValue;
177 double dValue;
178 std::vector<uint8_t> blobValue;
179
180 int iRet = resultSet->GetString(columnIndex, strValue);
181 EXPECT_EQ(E_OK, iRet);
182 EXPECT_EQ(resultSetData.strValue, strValue);
183
184 iRet = resultSet->GetInt(++columnIndex, iValue);
185 EXPECT_EQ(E_OK, iRet);
186 EXPECT_EQ(resultSetData.iValue, iValue);
187
188 iRet = resultSet->GetDouble(++columnIndex, dValue);
189 EXPECT_EQ(E_OK, iRet);
190 EXPECT_EQ(resultSetData.dValue, dValue);
191
192 iRet = resultSet->GetBlob(++columnIndex, blobValue);
193 EXPECT_EQ(E_OK, iRet);
194 EXPECT_EQ(resultSetData.blobValue.size(), blobValue.size());
195 for (int i = 0; i < blobValue.size(); i++) {
196 EXPECT_EQ(resultSetData.blobValue[i], blobValue[i]);
197 }
198 }
199
200 /* *
201 * @tc.name: RdbStore_StepResultSet_001
202 * @tc.desc: test StepResultSet
203 * @tc.type: FUNC
204 * @tc.require: AR000FKD4F
205 */
206 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_001, TestSize.Level1)
207 {
208 GenerateDefaultTable();
209
210 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
211 EXPECT_NE(resultSet, nullptr);
212 bool bResultSet = true;
213 int iRet = resultSet->IsStarted(bResultSet);
214 EXPECT_EQ(E_OK, iRet);
215 EXPECT_EQ(bResultSet, false);
216 EXPECT_EQ(resultSet->GoTo(1), E_OK);
217
218 bResultSet = false;
219 iRet = resultSet->IsAtFirstRow(bResultSet);
220 EXPECT_EQ(E_OK, iRet);
221 EXPECT_EQ(bResultSet, true);
222
223 CheckColumnType(resultSet, 0, ColumnType::TYPE_INTEGER);
224
225 CheckColumnType(resultSet, 1, ColumnType::TYPE_STRING);
226
227 CheckColumnType(resultSet, 2, ColumnType::TYPE_INTEGER);
228
229 CheckColumnType(resultSet, 3, ColumnType::TYPE_FLOAT);
230
231 CheckColumnType(resultSet, 4, ColumnType::TYPE_BLOB);
232
233 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
234 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
235
236 int position = -1;
237 iRet = resultSet->GetRowIndex(position);
238 EXPECT_EQ(E_OK, iRet);
239 EXPECT_EQ(1, position);
240 int count = -1;
241 iRet = resultSet->GetRowCount(count);
242 EXPECT_EQ(E_OK, iRet);
243 EXPECT_EQ(3, count);
244
245 CheckResultSetData(1, resultSet, g_resultSetData[0]);
246 }
247
248 /* *
249 * @tc.name: RdbStore_StepResultSet_002
250 * @tc.desc: normal testcase of StepResultSet
251 * @tc.type: FUNC
252 * @tc.require: AR000FKD4F
253 */
254 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_002, TestSize.Level1)
255 {
256 GenerateDefaultTable();
257 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
258 EXPECT_NE(resultSet, nullptr);
259
260 int count = -1;
261 resultSet->GetRowCount(count);
262 EXPECT_EQ(3, count);
263
264 int position = INT_MIN;
265 int iRet = resultSet->GetRowIndex(position);
266 EXPECT_EQ(E_OK, iRet);
267 EXPECT_EQ(-1, position);
268
269 bool bResultSet = true;
270 resultSet->IsAtFirstRow(bResultSet);
271 EXPECT_EQ(bResultSet, false);
272
273 EXPECT_EQ(E_OK, resultSet->GoToRow(2));
274
275 bResultSet = false;
276 iRet = resultSet->IsAtLastRow(bResultSet);
277 EXPECT_EQ(E_OK, iRet);
278 EXPECT_EQ(true, bResultSet);
279
280 EXPECT_EQ(E_OK, resultSet->GoToPreviousRow());
281
282 iRet = resultSet->GetRowIndex(position);
283 EXPECT_EQ(E_OK, iRet);
284 EXPECT_EQ(1, position);
285
286 EXPECT_EQ(E_OK, resultSet->GoToLastRow());
287
288 bResultSet = false;
289 iRet = resultSet->IsAtLastRow(bResultSet);
290 EXPECT_EQ(E_OK, iRet);
291 EXPECT_EQ(true, bResultSet);
292
293 bResultSet = false;
294 iRet = resultSet->IsStarted(bResultSet);
295 EXPECT_EQ(E_OK, iRet);
296 EXPECT_EQ(bResultSet, true);
297
298 bResultSet = true;
299 iRet = resultSet->IsEnded(bResultSet);
300 EXPECT_EQ(E_OK, iRet);
301 EXPECT_EQ(bResultSet, false);
302 }
303
304 /* *
305 * @tc.name: RdbStore_StepResultSet_003
306 * @tc.desc: normal testcase of StepResultSet
307 * @tc.type: FUNC
308 * @tc.require: AR000FKD4F
309 */
310 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_003, TestSize.Level1)
311 {
312 GenerateDefaultTable();
313 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
314 EXPECT_NE(resultSet, nullptr);
315
316 CheckResultSetAttribute(resultSet, -1, false, false, false);
317
318 int moveTimes = 0;
319 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
320 moveTimes++;
321
322 CheckResultSetAttribute(resultSet, 0, true, true, false);
323
324 int position = INT_MIN;
325 int iRet = resultSet->GetRowIndex(position);
326 EXPECT_EQ(E_OK, iRet);
327 EXPECT_EQ(0, position);
328 while (E_OK == resultSet->GoToNextRow()) {
329 moveTimes++;
330 }
331 /* Cursor is before first */
332
333 CheckResultSetAttribute(resultSet, 3, true, false, true);
334 }
335
336 /* *
337 * @tc.name: RdbStore_StepResultSet_004
338 * @tc.desc: normal testcase of StepResultSet
339 * @tc.type: FUNC
340 * @tc.require: AR000FKD4F
341 */
342 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_004, TestSize.Level1)
343 {
344 GenerateDefaultEmptyTable();
345 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
346 EXPECT_NE(resultSet, nullptr);
347
348 CheckResultSetAttribute(resultSet, -1, false, false, false);
349
350 EXPECT_NE(E_OK, resultSet->GoToNextRow());
351
352 int position = INT_MIN;
353 int iRet = resultSet->GetRowIndex(position);
354 EXPECT_EQ(E_OK, iRet);
355 EXPECT_EQ(0, position);
356
357 CheckResultSetAttribute(resultSet, 0, true, true, true);
358 }
359
360 /* *
361 * @tc.name: RdbStore_StepResultSet_005
362 * @tc.desc: normal testcase of StepResultSet
363 * @tc.type: FUNC
364 * @tc.require: AR000FKD4F
365 */
366 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_005, TestSize.Level1)
367 {
368 GenerateDefaultTable();
369 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
370 EXPECT_NE(resultSet, nullptr);
371
372 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
373
374 CheckResultSetAttribute(resultSet, 0, true, true, false);
375
376 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
377 CheckResultSetAttribute(resultSet, 0, true, true, false);
378
379 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
380 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
381
382 bool bResultSet = false;
383 int iRet = resultSet->IsAtFirstRow(bResultSet);
384 EXPECT_EQ(E_OK, iRet);
385 EXPECT_EQ(bResultSet, true);
386
387 bResultSet = false;
388 iRet = resultSet->IsStarted(bResultSet);
389 EXPECT_EQ(E_OK, iRet);
390 EXPECT_EQ(bResultSet, true);
391 }
392
393 /* *
394 * @tc.name: RdbStore_StepResultSet_006
395 * @tc.desc: normal testcase of StepResultSet for moveFirstWithoutEntry
396 * @tc.type: FUNC
397 * @tc.require: AR000FKD4F
398 */
399 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_006, TestSize.Level1)
400 {
401 GenerateDefaultEmptyTable();
402 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
403 EXPECT_NE(resultSet, nullptr);
404
405 EXPECT_NE(E_OK, resultSet->GoToFirstRow());
406
407 CheckResultSetAttribute(resultSet, 0, true, true, true);
408
409 EXPECT_NE(E_OK, resultSet->GoToNextRow());
410 EXPECT_NE(E_OK, resultSet->GoToFirstRow());
411
412 bool bResultSet = false;
413 int iRet = resultSet->IsAtFirstRow(bResultSet);
414 EXPECT_EQ(E_OK, iRet);
415 EXPECT_EQ(bResultSet, true);
416
417 bResultSet = false;
418 iRet = resultSet->IsStarted(bResultSet);
419 EXPECT_EQ(E_OK, iRet);
420 EXPECT_EQ(bResultSet, true);
421 }
422
423 /* *
424 * @tc.name: RdbStore_StepResultSet_007
425 * @tc.desc: normal testcase of StepResultSet for goToNextRow
426 * @tc.type: FUNC
427 * @tc.require: AR000FKD4F
428 */
429 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_007, TestSize.Level1)
430 {
431 GenerateDefaultTable();
432 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
433 EXPECT_NE(resultSet, nullptr);
434
435 int moveTimes = 0;
436 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
437 moveTimes++;
438 int position = INT_MIN;
439 bool bResultSet = true;
440 int iRet = resultSet->GetRowIndex(position);
441 EXPECT_EQ(E_OK, iRet);
442 EXPECT_EQ(0, position);
443
444 iRet = resultSet->IsEnded(bResultSet);
445 EXPECT_EQ(E_OK, iRet);
446 EXPECT_EQ(bResultSet, false);
447
448 while (E_OK == resultSet->GoToNextRow()) {
449 moveTimes++;
450 }
451 iRet = resultSet->GetRowIndex(position);
452 EXPECT_EQ(E_OK, iRet);
453 EXPECT_EQ(3, position);
454
455 bResultSet = false;
456 iRet = resultSet->IsEnded(bResultSet);
457 EXPECT_EQ(E_OK, iRet);
458 EXPECT_EQ(bResultSet, true);
459 }
460 /* *
461 * @tc.name: RdbStore_StepResultSet_008
462 * @tc.desc: normal testcase of StepResultSet for moveNextWithoutEntry
463 * @tc.type: FUNC
464 * @tc.require: AR000FKD4F
465 */
466 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_008, TestSize.Level1)
467 {
468 GenerateDefaultEmptyTable();
469 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
470 EXPECT_NE(resultSet, nullptr);
471
472 int moveTimes = 0;
473
474 EXPECT_NE(E_OK, resultSet->GoToFirstRow());
475 moveTimes++;
476 int position = INT_MIN;
477 bool bResultSet = false;
478 int iRet = resultSet->GetRowIndex(position);
479 EXPECT_EQ(E_OK, iRet);
480 EXPECT_EQ(0, position);
481
482 iRet = resultSet->IsEnded(bResultSet);
483 EXPECT_EQ(E_OK, iRet);
484 EXPECT_EQ(bResultSet, true);
485
486 while (E_OK == resultSet->GoToNextRow()) {
487 moveTimes++;
488 }
489 iRet = resultSet->GetRowIndex(position);
490 EXPECT_EQ(E_OK, iRet);
491 EXPECT_EQ(1, position);
492
493 bResultSet = false;
494 iRet = resultSet->IsEnded(bResultSet);
495 EXPECT_EQ(E_OK, iRet);
496 EXPECT_EQ(bResultSet, true);
497 }
498 /* *
499 * @tc.name: RdbStore_StepResultSet_009
500 * @tc.desc: normal testcase of StepResultSet for getInt
501 * @tc.type: FUNC
502 * @tc.require: AR000FKD4F
503 */
504 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_009, TestSize.Level1)
505 {
506 GenerateDefaultTable();
507 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
508 EXPECT_NE(resultSet, nullptr);
509
510 int iValue;
511 int iRet = resultSet->GetInt(0, iValue);
512 EXPECT_NE(E_OK, iRet);
513
514 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
515
516 iRet = resultSet->GetInt(0, iValue);
517 EXPECT_EQ(E_OK, iRet);
518 EXPECT_EQ(0, iValue);
519
520 iRet = resultSet->GetInt(1, iValue);
521 EXPECT_EQ(E_OK, iRet);
522 EXPECT_EQ(10, iValue);
523
524 iRet = resultSet->GetInt(2, iValue);
525 EXPECT_EQ(E_OK, iRet);
526 EXPECT_EQ(1, iValue);
527
528 iRet = resultSet->GetInt(3, iValue);
529 EXPECT_NE(E_OK, iRet);
530
531 int columnCount = 0;
532 iRet = resultSet->GetColumnCount(columnCount);
533 EXPECT_EQ(4, columnCount);
534 iRet = resultSet->GetInt(columnCount, iValue);
535 EXPECT_NE(E_OK, iRet);
536
537 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
538 iRet = resultSet->GetInt(0, iValue);
539 EXPECT_EQ(E_OK, iRet);
540 EXPECT_EQ(2, iValue);
541
542 int64_t longValue;
543 iRet = resultSet->GetLong(0, longValue);
544 EXPECT_EQ(E_OK, iRet);
545 EXPECT_EQ(2, longValue);
546
547 iRet = resultSet->GetInt(1, iValue);
548 EXPECT_EQ(E_OK, iRet);
549 EXPECT_EQ(-5, iValue);
550
551 iRet = resultSet->GetLong(1, longValue);
552 EXPECT_EQ(E_OK, iRet);
553 EXPECT_EQ(-5, longValue);
554
555 iRet = resultSet->GetInt(2, iValue);
556 EXPECT_EQ(E_OK, iRet);
557 EXPECT_EQ(2, iValue);
558 }
559 /* *
560 * @tc.name: RdbStore_StepResultSet_010
561 * @tc.desc: normal testcase of StepResultSet for getString
562 * @tc.type: FUNC
563 * @tc.require: AR000FKD4F
564 */
565 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_010, TestSize.Level1)
566 {
567 GenerateDefaultTable();
568 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
569 EXPECT_NE(resultSet, nullptr);
570
571 std::string strValue;
572 int iRet = resultSet->GetString(0, strValue);
573 EXPECT_NE(E_OK, iRet);
574
575 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
576
577 iRet = resultSet->GetString(0, strValue);
578 EXPECT_EQ(E_OK, iRet);
579 EXPECT_EQ("hello", strValue);
580 iRet = resultSet->GetString(1, strValue);
581 EXPECT_EQ(E_OK, iRet);
582 EXPECT_EQ("10", strValue);
583 iRet = resultSet->GetString(2, strValue);
584 EXPECT_EQ(E_OK, iRet);
585 EXPECT_EQ("1", strValue);
586
587 iRet = resultSet->GetString(3, strValue);
588 EXPECT_NE(E_OK, iRet);
589
590 int columnCount = 0;
591 iRet = resultSet->GetColumnCount(columnCount);
592 EXPECT_EQ(4, columnCount);
593 iRet = resultSet->GetString(columnCount, strValue);
594 EXPECT_NE(E_OK, iRet);
595
596 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
597 iRet = resultSet->GetString(0, strValue);
598 EXPECT_EQ(E_OK, iRet);
599 EXPECT_EQ("2", strValue);
600 iRet = resultSet->GetString(1, strValue);
601 EXPECT_EQ(E_OK, iRet);
602 EXPECT_EQ("-5", strValue);
603 iRet = resultSet->GetString(2, strValue);
604 EXPECT_EQ(E_OK, iRet);
605 EXPECT_EQ("2.5", strValue);
606 }
607
608 /* *
609 * @tc.name: RdbStore_StepResultSet_011
610 * @tc.desc: normal testcase of StepResultSet for GetDouble
611 * @tc.type: FUNC
612 * @tc.require: AR000FKD4F
613 */
614 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_011, TestSize.Level1)
615 {
616 GenerateDefaultTable();
617 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
618 EXPECT_NE(resultSet, nullptr);
619
620 double dValue;
621 int iRet = resultSet->GetDouble(0, dValue);
622 EXPECT_NE(E_OK, iRet);
623
624 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
625 iRet = resultSet->GetDouble(0, dValue);
626 EXPECT_EQ(E_OK, iRet);
627 EXPECT_EQ(0.0, dValue);
628 iRet = resultSet->GetDouble(1, dValue);
629 EXPECT_EQ(E_OK, iRet);
630 EXPECT_EQ(10.0, dValue);
631
632 iRet = resultSet->GetDouble(2, dValue);
633 EXPECT_EQ(E_OK, iRet);
634 EXPECT_EQ(1.0, dValue);
635
636 iRet = resultSet->GetDouble(3, dValue);
637 EXPECT_NE(E_OK, iRet);
638 int columnCount = 0;
639 iRet = resultSet->GetColumnCount(columnCount);
640 EXPECT_EQ(4, columnCount);
641 iRet = resultSet->GetDouble(columnCount, dValue);
642 EXPECT_NE(E_OK, iRet);
643
644 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
645 iRet = resultSet->GetDouble(0, dValue);
646 EXPECT_EQ(E_OK, iRet);
647 EXPECT_EQ(2.0, dValue);
648 iRet = resultSet->GetDouble(1, dValue);
649 EXPECT_EQ(E_OK, iRet);
650 EXPECT_EQ(-5.0, dValue);
651 iRet = resultSet->GetDouble(2, dValue);
652 EXPECT_EQ(E_OK, iRet);
653 EXPECT_EQ(2.5, dValue);
654 }
655
656 /* *
657 * @tc.name: RdbStore_StepResultSet_012
658 * @tc.desc: normal testcase of StepResultSet for getBlob
659 * @tc.type: FUNC
660 * @tc.require: AR000FKD4F
661 */
662 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_012, TestSize.Level1)
663 {
664 GenerateDefaultTable();
665 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
666 EXPECT_NE(resultSet, nullptr);
667
668 std::vector<uint8_t> blobValue;
669 int iRet = resultSet->GetBlob(0, blobValue);
670 EXPECT_NE(E_OK, iRet);
671
672 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
673 iRet = resultSet->GetBlob(0, blobValue);
674 EXPECT_EQ(E_OK, iRet);
675
676 string strBlob;
677 for (size_t i = 0; i < blobValue.size(); i++) {
678 strBlob += char(blobValue[i]);
679 }
680 EXPECT_EQ("hello", strBlob);
681
682 iRet = resultSet->GetBlob(1, blobValue);
683 EXPECT_NE(E_OK, iRet);
684
685 iRet = resultSet->GetBlob(2, blobValue);
686 EXPECT_NE(E_OK, iRet);
687
688 iRet = resultSet->GetBlob(3, blobValue);
689 EXPECT_EQ(E_OK, iRet);
690
691 strBlob.clear();
692 for (size_t i = 0; i < blobValue.size(); i++) {
693 strBlob += char(blobValue[i]);
694 }
695 char cValue = 66;
696 string strTmpValue(1, cValue);
697 EXPECT_EQ(strTmpValue, strBlob);
698
699 int columnCount = 0;
700 iRet = resultSet->GetColumnCount(columnCount);
701 EXPECT_EQ(4, columnCount);
702 iRet = resultSet->GetBlob(columnCount, blobValue);
703 EXPECT_NE(E_OK, iRet);
704
705 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
706 iRet = resultSet->GetBlob(3, blobValue);
707 EXPECT_EQ(E_OK, iRet);
708 }
709
710 /* *
711 * @tc.name: RdbStore_StepResultSet_013
712 * @tc.desc: normal testcase of StepResultSet for getBlob
713 * @tc.type: FUNC
714 * @tc.require: AR000FKD4F
715 */
716 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_013, TestSize.Level1)
717 {
718 GenerateDefaultTable();
719 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
720 EXPECT_NE(resultSet, nullptr);
721
722 ColumnType type;
723 int iRet = resultSet->GetColumnType(0, type);
724 EXPECT_NE(E_OK, iRet);
725
726 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
727 CheckColumnType(resultSet, 0, ColumnType::TYPE_INTEGER);
728
729 CheckColumnType(resultSet, 1, ColumnType::TYPE_STRING);
730
731 CheckColumnType(resultSet, 2, ColumnType::TYPE_INTEGER);
732
733 CheckColumnType(resultSet, 3, ColumnType::TYPE_FLOAT);
734
735 CheckColumnType(resultSet, 4, ColumnType::TYPE_BLOB);
736
737 int columnCount = 0;
738 iRet = resultSet->GetColumnCount(columnCount);
739 EXPECT_EQ(5, columnCount);
740 iRet = resultSet->GetColumnType(columnCount, type);
741 EXPECT_NE(E_OK, iRet);
742 }
743
744 /* *
745 * @tc.name: RdbStore_StepResultSet_014
746 * @tc.desc: normal testcase of StepResultSet for getColumnIndexForName
747 * @tc.type: FUNC
748 * @tc.require: AR000FKD4F
749 */
750 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_014, TestSize.Level1)
751 {
752 GenerateDefaultTable();
753 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
754 EXPECT_NE(resultSet, nullptr);
755
756 int columnIndex;
757 int iRet = resultSet->GetColumnIndex("data1", columnIndex);
758 EXPECT_EQ(E_OK, iRet);
759 EXPECT_EQ(1, columnIndex);
760
761 iRet = resultSet->GetColumnIndex("data2", columnIndex);
762 EXPECT_EQ(E_OK, iRet);
763 EXPECT_EQ(2, columnIndex);
764
765 iRet = resultSet->GetColumnIndex("data3", columnIndex);
766 EXPECT_EQ(E_OK, iRet);
767 EXPECT_EQ(3, columnIndex);
768
769 iRet = resultSet->GetColumnIndex("data4", columnIndex);
770 EXPECT_EQ(E_OK, iRet);
771 EXPECT_EQ(4, columnIndex);
772
773 iRet = resultSet->GetColumnIndex("jank.data1", columnIndex);
774 EXPECT_EQ(E_OK, iRet);
775 EXPECT_EQ(1, columnIndex);
776
777 iRet = resultSet->GetColumnIndex("datax", columnIndex);
778 EXPECT_EQ(E_ERROR, iRet);
779 EXPECT_EQ(-1, columnIndex);
780 }
781
782 /* *
783 * @tc.name: RdbStore_StepResultSet_015
784 * @tc.desc: normal testcase of StepResultSet for getColumnNameForIndex
785 * @tc.type: FUNC
786 * @tc.require: AR000FKD4F
787 */
788 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_015, TestSize.Level1)
789 {
790 GenerateDefaultTable();
791 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
792 EXPECT_NE(resultSet, nullptr);
793
794 std::vector<std::string> allColumnNames;
795 int iRet = resultSet->GetAllColumnNames(allColumnNames);
796 EXPECT_EQ(E_OK, iRet);
797
798 std::string columnName;
799 iRet = resultSet->GetColumnName(1, columnName);
800 EXPECT_EQ("data1", columnName);
801 EXPECT_EQ(allColumnNames[1], columnName);
802
803 iRet = resultSet->GetColumnName(2, columnName);
804 EXPECT_EQ("data2", columnName);
805 EXPECT_EQ(allColumnNames[2], columnName);
806
807 iRet = resultSet->GetColumnName(3, columnName);
808 EXPECT_EQ("data3", columnName);
809 EXPECT_EQ(allColumnNames[3], columnName);
810
811 iRet = resultSet->GetColumnName(4, columnName);
812 EXPECT_EQ("data4", columnName);
813 EXPECT_EQ(allColumnNames[4], columnName);
814
815 int columnCount = 0;
816 iRet = resultSet->GetColumnCount(columnCount);
817 EXPECT_EQ(5, columnCount);
818 iRet = resultSet->GetColumnName(columnCount, columnName);
819 EXPECT_NE(E_OK, iRet);
820 }
821
822 /* *
823 * @tc.name: RdbStore_StepResultSet_016
824 * @tc.desc: normal testcase of StepResultSet
825 * @tc.type: FUNC
826 * @tc.require: AR000FKD4F
827 */
828 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_016, TestSize.Level1)
829 {
830 GenerateDefaultTable();
831 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
832 EXPECT_NE(resultSet, nullptr);
833
834 bool bResultSet = false;
835 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
836 int iRet = resultSet->IsAtFirstRow(bResultSet);
837 EXPECT_EQ(E_OK, iRet);
838 EXPECT_EQ(bResultSet, true);
839
840 bResultSet = false;
841 iRet = resultSet->IsStarted(bResultSet);
842 EXPECT_EQ(E_OK, iRet);
843 EXPECT_EQ(bResultSet, true);
844
845 int iValue;
846 iRet = resultSet->GetInt(1, iValue);
847 EXPECT_EQ(E_OK, iRet);
848 EXPECT_EQ(10, iValue);
849
850 int64_t longValue;
851 iRet = resultSet->GetLong(1, longValue);
852 EXPECT_EQ(E_OK, iRet);
853 EXPECT_EQ(10, longValue);
854 }
855
856 /* *
857 * @tc.name: testGetRowCount003
858 * @tc.desc: normal testcase of StepResultSet for getRowCount
859 * @tc.type: FUNC
860 * @tc.require: AR000FKD4F
861 */
862 HWTEST_F(RdbStepResultSetTest, testGetRowCount003, TestSize.Level1)
863 {
864 GenerateDefaultTable();
865 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
866 EXPECT_NE(resultSet, nullptr);
867
868 bool bResultSet = true;
869 int iRet = resultSet->IsStarted(bResultSet);
870 EXPECT_EQ(E_OK, iRet);
871 EXPECT_EQ(bResultSet, false);
872
873 int count = -1;
874 iRet = resultSet->GetRowCount(count);
875 EXPECT_EQ(E_OK, iRet);
876 EXPECT_EQ(3, count);
877 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
878
879 bResultSet = false;
880 EXPECT_EQ(E_OK, resultSet->IsAtFirstRow(bResultSet));
881 EXPECT_EQ(bResultSet, true);
882
883 CheckResultSetData(1, resultSet, g_resultSetData[1]);
884
885 iRet = resultSet->GetRowCount(count);
886 EXPECT_EQ(E_OK, iRet);
887 EXPECT_EQ(3, count);
888
889 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
890 int position = INT_MIN;
891 iRet = resultSet->GetRowIndex(position);
892 EXPECT_EQ(E_OK, iRet);
893 EXPECT_EQ(1, position);
894
895 CheckResultSetData(1, resultSet, g_resultSetData[0]);
896
897 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
898 iRet = resultSet->GetRowIndex(position);
899 EXPECT_EQ(E_OK, iRet);
900 EXPECT_EQ(2, position);
901
902 iRet = resultSet->GetRowCount(count);
903 EXPECT_EQ(E_OK, iRet);
904 EXPECT_EQ(3, count);
905 }
906
907 /* *
908 * @tc.name: testGetRowCount004
909 * @tc.desc: normal testcase of StepResultSet for getRowCount
910 * @tc.type: FUNC
911 * @tc.require: AR000FKD4F
912 */
913 HWTEST_F(RdbStepResultSetTest, testGetRowCount004, TestSize.Level1)
914 {
915 GenerateDefaultTable();
916 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
917 EXPECT_NE(resultSet, nullptr);
918
919 bool bResultSet = true;
920 int iRet = resultSet->IsStarted(bResultSet);
921 EXPECT_EQ(E_OK, iRet);
922 EXPECT_EQ(bResultSet, false);
923 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
924
925 bResultSet = false;
926 iRet = resultSet->IsAtFirstRow(bResultSet);
927 EXPECT_EQ(E_OK, iRet);
928 EXPECT_EQ(bResultSet, true);
929
930 int count = -1;
931 iRet = resultSet->GetRowCount(count);
932 EXPECT_EQ(E_OK, iRet);
933 EXPECT_EQ(3, count);
934
935 CheckResultSetData(0, resultSet, g_resultSetData[1]);
936
937 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
938
939 int position = INT_MIN;
940 iRet = resultSet->GetRowIndex(position);
941 EXPECT_EQ(E_OK, iRet);
942 EXPECT_EQ(1, position);
943
944 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
945
946 iRet = resultSet->GetRowIndex(position);
947 EXPECT_EQ(E_OK, iRet);
948 EXPECT_EQ(2, position);
949
950 iRet = resultSet->GetRowCount(count);
951 EXPECT_EQ(E_OK, iRet);
952 EXPECT_EQ(3, count);
953
954 CheckResultSetData(0, resultSet, g_resultSetData[2]);
955 }
956
957 /* *
958 * @tc.name: testGoToRow005
959 * @tc.desc: normal testcase of StepResultSet for goToRow
960 * @tc.type: FUNC
961 * @tc.require: AR000FKD4F
962 */
963 HWTEST_F(RdbStepResultSetTest, testGoToRow005, TestSize.Level1)
964 {
965 GenerateDefaultTable();
966 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
967 EXPECT_NE(resultSet, nullptr);
968
969 bool bResultSet = true;
970 int iRet = resultSet->IsStarted(bResultSet);
971 EXPECT_EQ(E_OK, iRet);
972 EXPECT_EQ(bResultSet, false);
973 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
974
975 bResultSet = false;
976 iRet = resultSet->IsAtFirstRow(bResultSet);
977 EXPECT_EQ(E_OK, iRet);
978 EXPECT_EQ(bResultSet, true);
979
980 int position = INT_MIN;
981 iRet = resultSet->GetRowIndex(position);
982 EXPECT_EQ(E_OK, iRet);
983 EXPECT_EQ(0, position);
984
985 EXPECT_EQ(E_OK, resultSet->GoToRow(2));
986
987 iRet = resultSet->GetRowIndex(position);
988 EXPECT_EQ(E_OK, iRet);
989 EXPECT_EQ(2, position);
990
991 CheckResultSetData(0, resultSet, g_resultSetData[2]);
992
993 EXPECT_EQ(E_OK, resultSet->GoToRow(1));
994
995 iRet = resultSet->GetRowIndex(position);
996 EXPECT_EQ(E_OK, iRet);
997 EXPECT_EQ(1, position);
998
999 CheckResultSetData(0, resultSet, g_resultSetData[0]);
1000 }
1001
1002 /* *
1003 * @tc.name: testGo006
1004 * @tc.desc: normal testcase of StepResultSet for goToRow
1005 * @tc.type: FUNC
1006 * @tc.require: AR000FKD4F
1007 */
1008 HWTEST_F(RdbStepResultSetTest, testGo006, TestSize.Level1)
1009 {
1010 GenerateDefaultTable();
1011 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
1012 EXPECT_NE(resultSet, nullptr);
1013 int position = INT_MIN;
1014 int iRet = resultSet->GetRowIndex(position);
1015 EXPECT_EQ(E_OK, iRet);
1016 EXPECT_EQ(-1, position);
1017
1018 int count = -1;
1019 iRet = resultSet->GetRowCount(count);
1020 EXPECT_EQ(E_OK, iRet);
1021 EXPECT_EQ(3, count);
1022
1023 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1024
1025 iRet = resultSet->GetRowIndex(position);
1026 EXPECT_EQ(E_OK, iRet);
1027 EXPECT_EQ(0, position);
1028
1029 EXPECT_EQ(resultSet->GoTo(2), E_OK);
1030
1031 CheckResultSetData(1, resultSet, g_resultSetData[2]);
1032
1033 EXPECT_EQ(resultSet->GoTo(-2), E_OK);
1034
1035 iRet = resultSet->GetRowIndex(position);
1036 EXPECT_EQ(E_OK, iRet);
1037 EXPECT_EQ(0, position);
1038
1039 CheckResultSetData(1, resultSet, g_resultSetData[1]);
1040 }
1041
1042 /* *
1043 * @tc.name: testGoToPrevious007
1044 * @tc.desc: normal testcase of StepResultSet for go
1045 * @tc.type: FUNC
1046 * @tc.require: AR000FKD4F
1047 */
1048 HWTEST_F(RdbStepResultSetTest, testGoToPrevious007, TestSize.Level1)
1049 {
1050 GenerateDefaultTable();
1051 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1052 EXPECT_NE(resultSet, nullptr);
1053
1054 int count = -1;
1055 int iRet = resultSet->GetRowCount(count);
1056 EXPECT_EQ(E_OK, iRet);
1057 EXPECT_EQ(3, count);
1058
1059 bool bResultSet = true;
1060 iRet = resultSet->IsStarted(bResultSet);
1061 EXPECT_EQ(E_OK, iRet);
1062 EXPECT_EQ(bResultSet, false);
1063
1064 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1065
1066 bResultSet = false;
1067 iRet = resultSet->IsAtFirstRow(bResultSet);
1068 EXPECT_EQ(E_OK, iRet);
1069 EXPECT_EQ(bResultSet, true);
1070
1071 CheckResultSetData(0, resultSet, g_resultSetData[1]);
1072
1073 int ret = resultSet->GoToPreviousRow();
1074 EXPECT_NE(E_OK, ret);
1075
1076 CheckResultSetAttribute(resultSet, -1, false, false, false);
1077
1078 EXPECT_EQ(resultSet->GoTo(2), E_OK);
1079
1080 CheckResultSetData(0, resultSet, g_resultSetData[0]);
1081
1082 EXPECT_EQ(E_OK, resultSet->GoToLastRow());
1083
1084 iRet = resultSet->IsAtLastRow(bResultSet);
1085 EXPECT_EQ(E_OK, iRet);
1086 EXPECT_EQ(true, bResultSet);
1087
1088 EXPECT_EQ(E_OK, resultSet->GoToPreviousRow());
1089
1090 int position = INT_MIN;
1091 iRet = resultSet->GetRowIndex(position);
1092 EXPECT_EQ(E_OK, iRet);
1093 EXPECT_EQ(1, position);
1094
1095 EXPECT_NE(E_OK, resultSet->GoTo(3));
1096
1097 CheckResultSetAttribute(resultSet, 3, true, false, true);
1098 }
1099
1100 /* *
1101 * @tc.name: testSqlStep008
1102 * @tc.desc: normal testcase of SqlStep for go
1103 * @tc.type: FUNC
1104 * @tc.require: AR000FKD4F
1105 */
1106 HWTEST_F(RdbStepResultSetTest, testSqlStep008, TestSize.Level1)
1107 {
1108 GenerateDefaultTable();
1109 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1110 EXPECT_NE(resultSet, nullptr);
1111
1112 bool bResultSet = true;
1113 int iRet = resultSet->IsStarted(bResultSet);
1114 EXPECT_EQ(E_OK, iRet);
1115 EXPECT_EQ(bResultSet, false);
1116
1117 EXPECT_EQ(E_OK, resultSet->GoTo(1));
1118
1119 bResultSet = false;
1120 iRet = resultSet->IsAtFirstRow(bResultSet);
1121 EXPECT_EQ(E_OK, iRet);
1122 EXPECT_EQ(bResultSet, true);
1123
1124 CheckColumnType(resultSet, 0, ColumnType::TYPE_STRING);
1125
1126 CheckColumnType(resultSet, 1, ColumnType::TYPE_INTEGER);
1127
1128 CheckColumnType(resultSet, 2, ColumnType::TYPE_FLOAT);
1129
1130 CheckColumnType(resultSet, 3, ColumnType::TYPE_BLOB);
1131
1132 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1133 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
1134
1135 int position = INT_MIN;
1136 iRet = resultSet->GetRowIndex(position);
1137 EXPECT_EQ(E_OK, iRet);
1138 EXPECT_EQ(1, position);
1139
1140 int count = -1;
1141 iRet = resultSet->GetRowCount(count);
1142 EXPECT_EQ(E_OK, iRet);
1143 EXPECT_EQ(3, count);
1144
1145 CheckResultSetData(0, resultSet, g_resultSetData[0]);
1146 }
1147
1148 /* *
1149 * @tc.name: testSqlStep009
1150 * @tc.desc: normal testcase of SqlStep for go
1151 * @tc.type: FUNC
1152 * @tc.require: AR000FKD4F
1153 */
1154 HWTEST_F(RdbStepResultSetTest, testSqlStep009, TestSize.Level1)
1155 {
1156 GenerateDefaultTable();
1157 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1158 EXPECT_NE(resultSet, nullptr);
1159
1160 int count = -1;
1161 int iRet = resultSet->GetRowCount(count);
1162 EXPECT_EQ(E_OK, iRet);
1163 EXPECT_EQ(3, count);
1164
1165 int position = INT_MIN;
1166 iRet = resultSet->GetRowIndex(position);
1167 EXPECT_EQ(E_OK, iRet);
1168 EXPECT_EQ(-1, position);
1169
1170 bool bResultSet = true;
1171 iRet = resultSet->IsAtFirstRow(bResultSet);
1172 EXPECT_EQ(E_OK, iRet);
1173 EXPECT_EQ(bResultSet, false);
1174
1175 EXPECT_EQ(E_OK, resultSet->GoToRow(2));
1176
1177 bResultSet = false;
1178 iRet = resultSet->IsAtLastRow(bResultSet);
1179 EXPECT_EQ(E_OK, iRet);
1180 EXPECT_EQ(true, bResultSet);
1181
1182 EXPECT_EQ(E_OK, resultSet->GoToPreviousRow());
1183
1184 iRet = resultSet->GetRowIndex(position);
1185 EXPECT_EQ(E_OK, iRet);
1186 EXPECT_EQ(1, position);
1187
1188 EXPECT_EQ(E_OK, resultSet->GoToLastRow());
1189
1190 bResultSet = false;
1191 iRet = resultSet->IsAtLastRow(bResultSet);
1192 EXPECT_EQ(E_OK, iRet);
1193 EXPECT_EQ(true, bResultSet);
1194
1195 bResultSet = false;
1196 iRet = resultSet->IsAtLastRow(bResultSet);
1197 EXPECT_EQ(E_OK, iRet);
1198 EXPECT_EQ(true, bResultSet);
1199
1200 bResultSet = false;
1201 iRet = resultSet->IsStarted(bResultSet);
1202 EXPECT_EQ(E_OK, iRet);
1203 EXPECT_EQ(bResultSet, true);
1204
1205 bResultSet = true;
1206 iRet = resultSet->IsEnded(bResultSet);
1207 EXPECT_EQ(E_OK, iRet);
1208 EXPECT_EQ(bResultSet, false);
1209 }
1210
1211 /* *
1212 * @tc.name: testSqlStep010
1213 * @tc.desc: normal testcase of SqlStep for go
1214 * @tc.type: FUNC
1215 * @tc.require: AR000FKD4F
1216 */
1217 HWTEST_F(RdbStepResultSetTest, testSqlStep010, TestSize.Level1)
1218 {
1219 GenerateDefaultTable();
1220 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1221 EXPECT_NE(resultSet, nullptr);
1222
1223 CheckResultSetAttribute(resultSet, -1, false, false, false);
1224
1225 int moveTimes = 0;
1226 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
1227 moveTimes++;
1228
1229 CheckResultSetAttribute(resultSet, 0, true, true, false);
1230
1231 while (E_OK == resultSet->GoToNextRow()) {
1232 moveTimes++;
1233 }
1234
1235 CheckResultSetAttribute(resultSet, 3, true, false, true);
1236 }
1237
1238 /* *
1239 * @tc.name: testSqlStep011
1240 * @tc.desc: normal testcase of SqlStep for GetString()
1241 * @tc.type: FUNC
1242 * @tc.require: NA
1243 */
1244 HWTEST_F(RdbStepResultSetTest, testSqlStep011, TestSize.Level1)
1245 {
1246 GenerateDefaultEmptyTable();
1247
1248 std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
1249 const char arr[] = { 0X11, 0X22, 0X33, 0X44, 0X55, 0X00, 0X66, 0X77, 0X00 };
1250 size_t arrLen = sizeof(arr);
1251 uint8_t uValue = 66;
1252 std::vector<uint8_t> typeBlob;
1253 typeBlob.push_back(uValue);
1254 store->ExecuteSql(insertSql, std::vector<ValueObject>{ ValueObject(std::string(arr, arrLen)), ValueObject((int)10),
1255 ValueObject((double)1.0), ValueObject((std::vector<uint8_t>)typeBlob) });
1256 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1257 EXPECT_NE(resultSet, nullptr);
1258
1259 int iRet = resultSet->GoToFirstRow();
1260 EXPECT_EQ(E_OK, iRet);
1261 bool bResultSet = false;
1262 iRet = resultSet->IsAtFirstRow(bResultSet);
1263 EXPECT_EQ(E_OK, iRet);
1264 EXPECT_EQ(bResultSet, true);
1265
1266 std::string stringValue;
1267 iRet = resultSet->GetString(0, stringValue);
1268 size_t stringValueLen = stringValue.length();
1269 EXPECT_EQ(E_OK, iRet);
1270 EXPECT_EQ(arrLen, stringValueLen);
1271 }
1272
1273 /* *
1274 * @tc.name: testSqlStep012
1275 * @tc.desc: Normal testcase of SqlStep for constructor std::vector<ValueObject>
1276 * @tc.type: FUNC
1277 */
1278 HWTEST_F(RdbStepResultSetTest, testSqlStep012, TestSize.Level1)
1279 {
1280 GenerateDefaultEmptyTable();
1281
1282 std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
1283 const char arr[] = { 0X11, 0X22, 0X33, 0X44, 0X55, 0X00, 0X66, 0X77, 0X00 };
1284 size_t arrLen = sizeof(arr);
1285 uint8_t uValue = 66;
1286 std::vector<uint8_t> typeBlob;
1287 typeBlob.push_back(uValue);
1288 store->ExecuteSql(insertSql, std::vector<ValueObject>{ ValueObject(std::string(arr, arrLen)), ValueObject((int)10),
1289 ValueObject((double)1.0), ValueObject((std::vector<uint8_t>)typeBlob) });
1290
1291 std::shared_ptr<ResultSet> resultSet =
1292 store->QueryByStep("SELECT ? FROM test", std::vector<ValueObject>{ ValueObject((std::string) "data1") });
1293 EXPECT_NE(resultSet, nullptr);
1294
1295 int iRet = resultSet->GoToFirstRow();
1296 EXPECT_EQ(E_OK, iRet);
1297 bool bResultSet = false;
1298 iRet = resultSet->IsAtFirstRow(bResultSet);
1299 EXPECT_EQ(E_OK, iRet);
1300 EXPECT_EQ(bResultSet, true);
1301
1302 EXPECT_EQ(E_OK, resultSet->Close());
1303 }
1304
1305 /* *
1306 * @tc.name: testSqlStep013
1307 * @tc.desc: Abnormal testcase of SqlStep, if close resultSet before query
1308 * @tc.type: FUNC
1309 */
1310 HWTEST_F(RdbStepResultSetTest, testSqlStep013, TestSize.Level1)
1311 {
1312 GenerateDefaultTable();
1313
1314 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
1315 EXPECT_NE(resultSet, nullptr);
1316
1317 EXPECT_EQ(E_OK, resultSet->Close());
1318
1319 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->GoToNextRow());
1320
1321 std::vector<std::string> columnNames;
1322 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->GetAllColumnNames(columnNames));
1323
1324 ColumnType columnType;
1325 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->GetColumnType(1, columnType));
1326
1327 std::vector<uint8_t> blob;
1328 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->GetBlob(1, blob));
1329
1330 std::string valueString;
1331 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->GetString(1, valueString));
1332
1333 int valueInt;
1334 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->GetInt(1, valueInt));
1335
1336 int64_t valueInt64;
1337 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->GetLong(1, valueInt64));
1338
1339 double valuedouble;
1340 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->GetDouble(1, valuedouble));
1341
1342 std::string modifyTime;
1343 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->GetModifyTime(modifyTime));
1344
1345 ValueObject object;
1346 EXPECT_EQ(E_STEP_RESULT_CLOSED, resultSet->Get(4, object));
1347 }
1348
1349 /* *
1350 * @tc.name: testSqlStep014
1351 * @tc.desc: Abnormal testcase of SqlStep for GoToRow, if connection counts over limit
1352 * @tc.type: FUNC
1353 */
1354 HWTEST_F(RdbStepResultSetTest, testSqlStep014, TestSize.Level1)
1355 {
1356 GenerateDefaultTable();
1357
1358 std::shared_ptr<ResultSet> resultSet1 = store->QueryByStep("SELECT * FROM test");
1359 EXPECT_NE(resultSet1, nullptr);
1360
1361 std::shared_ptr<ResultSet> resultSet2 = store->QueryByStep("SELECT * FROM test");
1362 EXPECT_NE(resultSet2, nullptr);
1363
1364 std::shared_ptr<ResultSet> resultSet3 = store->QueryByStep("SELECT * FROM test");
1365 EXPECT_NE(resultSet2, nullptr);
1366
1367 std::shared_ptr<ResultSet> resultSet4 = store->QueryByStep("SELECT * FROM test");
1368 EXPECT_NE(resultSet2, nullptr);
1369
1370 std::shared_ptr<ResultSet> resultSet5 = store->QueryByStep("SELECT * FROM test");
1371 EXPECT_NE(resultSet2, nullptr);
1372
1373 EXPECT_EQ(E_CON_OVER_LIMIT, resultSet5->GoToRow(1));
1374
1375 EXPECT_EQ(E_OK, resultSet1->Close());
1376 EXPECT_EQ(E_OK, resultSet2->Close());
1377 EXPECT_EQ(E_OK, resultSet3->Close());
1378 EXPECT_EQ(E_OK, resultSet4->Close());
1379 EXPECT_EQ(E_OK, resultSet5->Close());
1380 }
1381
1382 /* *
1383 * @tc.name: testSqlStep015
1384 * @tc.desc: Abnormal testcase of SqlStep for QueryByStep, if sql is inValid
1385 * @tc.type: FUNC
1386 */
1387 HWTEST_F(RdbStepResultSetTest, testSqlStep015, TestSize.Level1)
1388 {
1389 GenerateDefaultTable();
1390
1391 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SE");
1392 EXPECT_NE(resultSet, nullptr);
1393
1394 std::vector<std::string> columnNames;
1395 EXPECT_EQ(E_EXECUTE_IN_STEP_QUERY, resultSet->GetAllColumnNames(columnNames));
1396
1397 EXPECT_EQ(E_OK, resultSet->Close());
1398 }
1399
1400 /* *
1401 * @tc.name: testSqlStep016
1402 * @tc.desc: Abnormal testcase of SqlStep for GetSize, if rowPos is inValid
1403 * @tc.type: FUNC
1404 */
1405 HWTEST_F(RdbStepResultSetTest, testSqlStep016, TestSize.Level1)
1406 {
1407 GenerateDefaultTable();
1408
1409 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SE");
1410 EXPECT_NE(resultSet, nullptr);
1411
1412 size_t size;
1413 EXPECT_EQ(E_STEP_RESULT_QUERY_NOT_EXECUTED, resultSet->GetSize(2, size));
1414
1415 EXPECT_EQ(E_OK, resultSet->Close());
1416 EXPECT_EQ(true, resultSet->IsClosed());
1417 }
1418
1419 /* *
1420 * @tc.name: testSqlStep017
1421 * @tc.desc: Abnormal testcase for build query string
1422 * @tc.type: FUNC
1423 */
1424 HWTEST_F(RdbStepResultSetTest, testSqlStep017, TestSize.Level1)
1425 {
1426 std::vector<std::string> columns = { "data1", "data2" };
1427
1428 std::string outSql;
1429 int errCode = SqliteSqlBuilder::BuildQueryString(false, "", columns, "", "", "", "", 0, 0, outSql);
1430 EXPECT_EQ(E_EMPTY_TABLE_NAME, errCode);
1431 }
1432 } // namespace NativeRdb
1433 } // namespace OHOS