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