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 "cache_result_set.h"
22 #include "common.h"
23 #include "rdb_errno.h"
24 #include "rdb_helper.h"
25 #include "rdb_open_callback.h"
26 #include "result_set_proxy.h"
27 #include "sqlite_sql_builder.h"
28
29 using namespace testing::ext;
30 using namespace OHOS::NativeRdb;
31 namespace OHOS {
32 namespace NativeRdb {
33 struct ResultSetData {
34 std::string strValue;
35 int iValue;
36 double dValue;
37 std::vector<uint8_t> blobValue;
38 };
39
40 class RdbStepResultSetTest : public testing::Test {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase(void);
44 void SetUp();
45 void TearDown();
46 void GenerateDefaultTable();
47 void GenerateDefaultEmptyTable();
48 void CheckColumnType(std::shared_ptr<ResultSet> resultSet, int columnIndex, ColumnType type);
49 void CheckResultSetAttribute(
50 std::shared_ptr<ResultSet> resultSet, int pos, bool isStart, bool isAtFirstRow, bool isEnded);
51 void CheckResultSetData(int columnIndex, std::shared_ptr<ResultSet> resultSet, ResultSetData &rowData);
52
53 static const std::string DATABASE_NAME;
54 static std::shared_ptr<RdbStore> store;
55 static ResultSetData g_resultSetData[3];
56 };
57
58 const std::string RdbStepResultSetTest::DATABASE_NAME = RDB_TEST_PATH + "stepResultSet_test.db";
59 std::shared_ptr<RdbStore> RdbStepResultSetTest::store = nullptr;
60 ResultSetData RdbStepResultSetTest::g_resultSetData[3] = { { "2", -5, 2.5, std::vector<uint8_t>{} },
61 { "hello", 10, 1.0, std::vector<uint8_t>{ 66 } }, { "hello world", 3, 1.8, std::vector<uint8_t>{} } };
62
63 class RdbStepResultSetOpenCallback : public RdbOpenCallback {
64 public:
65 int OnCreate(RdbStore &store) override;
66 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
67 static const std::string CREATE_TABLE_TEST;
68 };
69
OnCreate(RdbStore & store)70 int RdbStepResultSetOpenCallback::OnCreate(RdbStore &store)
71 {
72 return E_OK;
73 }
74
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)75 int RdbStepResultSetOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
76 {
77 return E_OK;
78 }
79
SetUpTestCase(void)80 void RdbStepResultSetTest::SetUpTestCase(void)
81 {
82 int errCode = E_OK;
83 RdbHelper::DeleteRdbStore(DATABASE_NAME);
84 RdbStoreConfig config(RdbStepResultSetTest::DATABASE_NAME);
85 RdbStepResultSetOpenCallback helper;
86 RdbStepResultSetTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
87 EXPECT_NE(RdbStepResultSetTest::store, nullptr);
88 EXPECT_EQ(errCode, E_OK);
89 }
90
TearDownTestCase(void)91 void RdbStepResultSetTest::TearDownTestCase(void)
92 {
93 RdbHelper::DeleteRdbStore(RdbStepResultSetTest::DATABASE_NAME);
94 }
95
SetUp(void)96 void RdbStepResultSetTest::SetUp(void)
97 {
98 store->ExecuteSql("DELETE FROM test");
99 }
100
TearDown(void)101 void RdbStepResultSetTest::TearDown(void)
102 {
103 RdbHelper::ClearCache();
104 }
105
GenerateDefaultTable()106 void RdbStepResultSetTest::GenerateDefaultTable()
107 {
108 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
109 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
110 store->ExecuteSql(createTableSql);
111
112 std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
113
114 /* insert first entry data */
115 uint8_t uValue = 66;
116 std::vector<uint8_t> typeBlob;
117 typeBlob.push_back(uValue);
118 store->ExecuteSql(insertSql, std::vector<ValueObject>{ ValueObject(std::string("hello")), ValueObject((int)10),
119 ValueObject((double)1.0), ValueObject((std::vector<uint8_t>)typeBlob) });
120
121 /* insert second entry data */
122 typeBlob.clear();
123 store->ExecuteSql(insertSql, std::vector<ValueObject>{
124 ValueObject(std::string("2")), ValueObject((int)-5), ValueObject((double)2.5),
125 ValueObject() // set double value 2.5
126 });
127
128 /* insert third entry data */
129 store->ExecuteSql(insertSql, std::vector<ValueObject>{
130 ValueObject(std::string("hello world")), ValueObject((int)3),
131 ValueObject((double)1.8), ValueObject() // set int value 3, double 1.8
132 });
133 }
134
GenerateDefaultEmptyTable()135 void RdbStepResultSetTest::GenerateDefaultEmptyTable()
136 {
137 std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
138 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
139 store->ExecuteSql(createTableSql);
140 }
141
CheckColumnType(std::shared_ptr<ResultSet> resultSet,int columnIndex,ColumnType type)142 void RdbStepResultSetTest::CheckColumnType(std::shared_ptr<ResultSet> resultSet, int columnIndex, ColumnType type)
143 {
144 ColumnType columnType;
145 int iRet = resultSet->GetColumnType(columnIndex, columnType);
146 EXPECT_EQ(E_OK, iRet);
147 EXPECT_EQ(columnType, type);
148 }
149
CheckResultSetAttribute(std::shared_ptr<ResultSet> resultSet,int pos,bool isStart,bool isAtFirstRow,bool isEnded)150 void RdbStepResultSetTest::CheckResultSetAttribute(
151 std::shared_ptr<ResultSet> resultSet, int pos, bool isStart, bool isAtFirstRow, bool isEnded)
152 {
153 int position = -1;
154 int iRet = resultSet->GetRowIndex(position);
155 EXPECT_EQ(E_OK, iRet);
156 EXPECT_EQ(pos, position);
157
158 bool bResultSet = !isStart;
159 iRet = resultSet->IsStarted(bResultSet);
160 EXPECT_EQ(E_OK, iRet);
161 EXPECT_EQ(isStart, bResultSet);
162
163 bResultSet = !isAtFirstRow;
164 iRet = resultSet->IsAtFirstRow(bResultSet);
165 EXPECT_EQ(E_OK, iRet);
166 EXPECT_EQ(isAtFirstRow, bResultSet);
167
168 bResultSet = !isEnded;
169 iRet = resultSet->IsEnded(bResultSet);
170 EXPECT_EQ(E_OK, iRet);
171 EXPECT_EQ(isEnded, bResultSet);
172 }
173
CheckResultSetData(int columnIndex,std::shared_ptr<ResultSet> resultSet,ResultSetData & resultSetData)174 void RdbStepResultSetTest::CheckResultSetData(
175 int columnIndex, std::shared_ptr<ResultSet> resultSet, ResultSetData &resultSetData)
176 {
177 std::string strValue;
178 int iValue;
179 double dValue;
180 std::vector<uint8_t> blobValue;
181
182 int iRet = resultSet->GetString(columnIndex, strValue);
183 EXPECT_EQ(E_OK, iRet);
184 EXPECT_EQ(resultSetData.strValue, strValue);
185
186 iRet = resultSet->GetInt(++columnIndex, iValue);
187 EXPECT_EQ(E_OK, iRet);
188 EXPECT_EQ(resultSetData.iValue, iValue);
189
190 iRet = resultSet->GetDouble(++columnIndex, dValue);
191 EXPECT_EQ(E_OK, iRet);
192 EXPECT_EQ(resultSetData.dValue, dValue);
193
194 iRet = resultSet->GetBlob(++columnIndex, blobValue);
195 EXPECT_EQ(E_OK, iRet);
196 EXPECT_EQ(resultSetData.blobValue.size(), blobValue.size());
197 for (int i = 0; i < blobValue.size(); i++) {
198 EXPECT_EQ(resultSetData.blobValue[i], blobValue[i]);
199 }
200 }
201
202 /* *
203 * @tc.name: RdbStore_StepResultSet_001
204 * @tc.desc: test StepResultSet
205 * @tc.type: FUNC
206 * @tc.require: AR000FKD4F
207 */
208 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_001, TestSize.Level1)
209 {
210 GenerateDefaultTable();
211
212 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
213 EXPECT_NE(resultSet, nullptr);
214 bool bResultSet = true;
215 int iRet = resultSet->IsStarted(bResultSet);
216 EXPECT_EQ(E_OK, iRet);
217 EXPECT_EQ(bResultSet, false);
218 EXPECT_EQ(resultSet->GoTo(1), E_OK);
219
220 bResultSet = false;
221 iRet = resultSet->IsAtFirstRow(bResultSet);
222 EXPECT_EQ(E_OK, iRet);
223 EXPECT_EQ(bResultSet, true);
224
225 CheckColumnType(resultSet, 0, ColumnType::TYPE_INTEGER);
226
227 CheckColumnType(resultSet, 1, ColumnType::TYPE_STRING);
228
229 CheckColumnType(resultSet, 2, ColumnType::TYPE_INTEGER);
230
231 CheckColumnType(resultSet, 3, ColumnType::TYPE_FLOAT);
232
233 CheckColumnType(resultSet, 4, ColumnType::TYPE_BLOB);
234
235 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
236 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
237
238 int position = -1;
239 iRet = resultSet->GetRowIndex(position);
240 EXPECT_EQ(E_OK, iRet);
241 EXPECT_EQ(1, position);
242 int count = -1;
243 iRet = resultSet->GetRowCount(count);
244 EXPECT_EQ(E_OK, iRet);
245 EXPECT_EQ(3, count);
246
247 CheckResultSetData(1, resultSet, g_resultSetData[0]);
248 }
249
250 /* *
251 * @tc.name: RdbStore_StepResultSet_002
252 * @tc.desc: normal testcase of StepResultSet
253 * @tc.type: FUNC
254 * @tc.require: AR000FKD4F
255 */
256 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_002, TestSize.Level1)
257 {
258 GenerateDefaultTable();
259 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
260 EXPECT_NE(resultSet, nullptr);
261
262 int count = -1;
263 resultSet->GetRowCount(count);
264 EXPECT_EQ(3, count);
265
266 int position = INT_MIN;
267 int iRet = resultSet->GetRowIndex(position);
268 EXPECT_EQ(E_OK, iRet);
269 EXPECT_EQ(-1, position);
270
271 bool bResultSet = true;
272 resultSet->IsAtFirstRow(bResultSet);
273 EXPECT_EQ(bResultSet, false);
274
275 EXPECT_EQ(E_OK, resultSet->GoToRow(2));
276
277 bResultSet = false;
278 iRet = resultSet->IsAtLastRow(bResultSet);
279 EXPECT_EQ(E_OK, iRet);
280 EXPECT_EQ(true, bResultSet);
281
282 EXPECT_EQ(E_OK, resultSet->GoToPreviousRow());
283
284 iRet = resultSet->GetRowIndex(position);
285 EXPECT_EQ(E_OK, iRet);
286 EXPECT_EQ(1, position);
287
288 EXPECT_EQ(E_OK, resultSet->GoToLastRow());
289
290 bResultSet = false;
291 iRet = resultSet->IsAtLastRow(bResultSet);
292 EXPECT_EQ(E_OK, iRet);
293 EXPECT_EQ(true, bResultSet);
294
295 bResultSet = false;
296 iRet = resultSet->IsStarted(bResultSet);
297 EXPECT_EQ(E_OK, iRet);
298 EXPECT_EQ(bResultSet, true);
299
300 bResultSet = true;
301 iRet = resultSet->IsEnded(bResultSet);
302 EXPECT_EQ(E_OK, iRet);
303 EXPECT_EQ(bResultSet, false);
304 }
305
306 /* *
307 * @tc.name: RdbStore_StepResultSet_003
308 * @tc.desc: normal testcase of StepResultSet
309 * @tc.type: FUNC
310 * @tc.require: AR000FKD4F
311 */
312 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_003, TestSize.Level1)
313 {
314 GenerateDefaultTable();
315 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
316 EXPECT_NE(resultSet, nullptr);
317
318 CheckResultSetAttribute(resultSet, -1, false, false, false);
319
320 int moveTimes = 0;
321 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
322 moveTimes++;
323
324 CheckResultSetAttribute(resultSet, 0, true, true, false);
325
326 int position = INT_MIN;
327 int iRet = resultSet->GetRowIndex(position);
328 EXPECT_EQ(E_OK, iRet);
329 EXPECT_EQ(0, position);
330 while (E_OK == resultSet->GoToNextRow()) {
331 moveTimes++;
332 }
333 /* Cursor is before first */
334
335 CheckResultSetAttribute(resultSet, 3, true, false, true);
336 }
337
338 /* *
339 * @tc.name: RdbStore_StepResultSet_004
340 * @tc.desc: normal testcase of StepResultSet
341 * @tc.type: FUNC
342 * @tc.require: AR000FKD4F
343 */
344 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_004, TestSize.Level1)
345 {
346 GenerateDefaultEmptyTable();
347 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
348 EXPECT_NE(resultSet, nullptr);
349
350 CheckResultSetAttribute(resultSet, -1, false, false, true);
351
352 auto res = resultSet->GoToNextRow();
353 EXPECT_NE(E_OK, res);
354
355 int position = INT_MIN;
356 int iRet = resultSet->GetRowIndex(position);
357 EXPECT_EQ(E_OK, iRet);
358 EXPECT_EQ(-1, position);
359
360 CheckResultSetAttribute(resultSet, -1, false, false, true);
361 }
362
363 /* *
364 * @tc.name: RdbStore_StepResultSet_005
365 * @tc.desc: normal testcase of StepResultSet
366 * @tc.type: FUNC
367 * @tc.require: AR000FKD4F
368 */
369 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_005, TestSize.Level1)
370 {
371 GenerateDefaultTable();
372 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
373 EXPECT_NE(resultSet, nullptr);
374
375 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
376
377 CheckResultSetAttribute(resultSet, 0, true, true, false);
378
379 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
380 CheckResultSetAttribute(resultSet, 0, true, true, false);
381
382 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
383 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
384
385 bool bResultSet = false;
386 int iRet = resultSet->IsAtFirstRow(bResultSet);
387 EXPECT_EQ(E_OK, iRet);
388 EXPECT_EQ(bResultSet, true);
389
390 bResultSet = false;
391 iRet = resultSet->IsStarted(bResultSet);
392 EXPECT_EQ(E_OK, iRet);
393 EXPECT_EQ(bResultSet, true);
394 }
395
396 /* *
397 * @tc.name: RdbStore_StepResultSet_006
398 * @tc.desc: normal testcase of StepResultSet for moveFirstWithoutEntry
399 * @tc.type: FUNC
400 * @tc.require: AR000FKD4F
401 */
402 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_006, TestSize.Level1)
403 {
404 GenerateDefaultEmptyTable();
405 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
406 EXPECT_NE(resultSet, nullptr);
407
408 EXPECT_NE(E_OK, resultSet->GoToFirstRow());
409
410 CheckResultSetAttribute(resultSet, -1, false, false, true);
411
412 EXPECT_NE(E_OK, resultSet->GoToNextRow());
413 EXPECT_NE(E_OK, resultSet->GoToFirstRow());
414
415 bool bResultSet = false;
416 int iRet = resultSet->IsAtFirstRow(bResultSet);
417 EXPECT_EQ(E_OK, iRet);
418 EXPECT_EQ(bResultSet, false);
419
420 bResultSet = false;
421 iRet = resultSet->IsStarted(bResultSet);
422 EXPECT_EQ(E_OK, iRet);
423 EXPECT_EQ(bResultSet, false);
424 }
425
426 /* *
427 * @tc.name: RdbStore_StepResultSet_007
428 * @tc.desc: normal testcase of StepResultSet for goToNextRow
429 * @tc.type: FUNC
430 * @tc.require: AR000FKD4F
431 */
432 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_007, TestSize.Level1)
433 {
434 GenerateDefaultTable();
435 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
436 EXPECT_NE(resultSet, nullptr);
437
438 int moveTimes = 0;
439 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
440 moveTimes++;
441 int position = INT_MIN;
442 bool bResultSet = true;
443 int iRet = resultSet->GetRowIndex(position);
444 EXPECT_EQ(E_OK, iRet);
445 EXPECT_EQ(0, position);
446
447 iRet = resultSet->IsEnded(bResultSet);
448 EXPECT_EQ(E_OK, iRet);
449 EXPECT_EQ(bResultSet, false);
450
451 while (E_OK == resultSet->GoToNextRow()) {
452 moveTimes++;
453 }
454 iRet = resultSet->GetRowIndex(position);
455 EXPECT_EQ(E_OK, iRet);
456 EXPECT_EQ(3, position);
457
458 bResultSet = false;
459 iRet = resultSet->IsEnded(bResultSet);
460 EXPECT_EQ(E_OK, iRet);
461 EXPECT_EQ(bResultSet, true);
462 }
463 /* *
464 * @tc.name: RdbStore_StepResultSet_008
465 * @tc.desc: normal testcase of StepResultSet for moveNextWithoutEntry
466 * @tc.type: FUNC
467 * @tc.require: AR000FKD4F
468 */
469 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_008, TestSize.Level1)
470 {
471 GenerateDefaultEmptyTable();
472 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
473 EXPECT_NE(resultSet, nullptr);
474
475 EXPECT_NE(E_OK, resultSet->GoToFirstRow());
476 int position = INT_MIN;
477 bool bResultSet = false;
478 int iRet = resultSet->GetRowIndex(position);
479 EXPECT_EQ(E_OK, iRet);
480 EXPECT_EQ(-1, 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 }
488 iRet = resultSet->GetRowIndex(position);
489 EXPECT_EQ(E_OK, iRet);
490 EXPECT_EQ(-1, position);
491
492 bResultSet = false;
493 iRet = resultSet->IsEnded(bResultSet);
494 EXPECT_EQ(E_OK, iRet);
495 EXPECT_EQ(bResultSet, true);
496 }
497 /* *
498 * @tc.name: RdbStore_StepResultSet_009
499 * @tc.desc: normal testcase of StepResultSet for getInt
500 * @tc.type: FUNC
501 * @tc.require: AR000FKD4F
502 */
503 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_009, TestSize.Level1)
504 {
505 GenerateDefaultTable();
506 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
507 EXPECT_NE(resultSet, nullptr);
508
509 int iValue;
510 int iRet = resultSet->GetInt(0, iValue);
511 EXPECT_NE(E_OK, iRet);
512
513 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
514
515 iRet = resultSet->GetInt(0, iValue);
516 EXPECT_EQ(E_OK, iRet);
517 EXPECT_EQ(0, iValue);
518
519 iRet = resultSet->GetInt(1, iValue);
520 EXPECT_EQ(E_OK, iRet);
521 EXPECT_EQ(10, iValue);
522
523 iRet = resultSet->GetInt(2, iValue);
524 EXPECT_EQ(E_OK, iRet);
525 EXPECT_EQ(1, iValue);
526
527 iRet = resultSet->GetInt(3, iValue);
528 EXPECT_EQ(E_OK, iRet);
529
530 int columnCount = 0;
531 iRet = resultSet->GetColumnCount(columnCount);
532 EXPECT_EQ(4, columnCount);
533 iRet = resultSet->GetInt(columnCount, iValue);
534 EXPECT_NE(E_OK, iRet);
535
536 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
537 iRet = resultSet->GetInt(0, iValue);
538 EXPECT_EQ(E_OK, iRet);
539 EXPECT_EQ(2, iValue);
540
541 int64_t longValue;
542 iRet = resultSet->GetLong(0, longValue);
543 EXPECT_EQ(E_OK, iRet);
544 EXPECT_EQ(2, longValue);
545
546 iRet = resultSet->GetInt(1, iValue);
547 EXPECT_EQ(E_OK, iRet);
548 EXPECT_EQ(-5, iValue);
549
550 iRet = resultSet->GetLong(1, longValue);
551 EXPECT_EQ(E_OK, iRet);
552 EXPECT_EQ(-5, longValue);
553
554 iRet = resultSet->GetInt(2, iValue);
555 EXPECT_EQ(E_OK, iRet);
556 EXPECT_EQ(2, iValue);
557 }
558 /* *
559 * @tc.name: RdbStore_StepResultSet_010
560 * @tc.desc: normal testcase of StepResultSet for getString
561 * @tc.type: FUNC
562 * @tc.require: AR000FKD4F
563 */
564 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_010, TestSize.Level1)
565 {
566 GenerateDefaultTable();
567 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
568 EXPECT_NE(resultSet, nullptr);
569
570 std::string strValue;
571 int iRet = resultSet->GetString(0, strValue);
572 EXPECT_NE(E_OK, iRet);
573
574 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
575
576 iRet = resultSet->GetString(0, strValue);
577 EXPECT_EQ(E_OK, iRet);
578 EXPECT_EQ("hello", strValue);
579 iRet = resultSet->GetString(1, strValue);
580 EXPECT_EQ(E_OK, iRet);
581 EXPECT_EQ("10", strValue);
582 iRet = resultSet->GetString(2, strValue);
583 EXPECT_EQ(E_OK, iRet);
584 EXPECT_EQ("1", strValue);
585
586 iRet = resultSet->GetString(3, strValue);
587 EXPECT_EQ(E_OK, iRet);
588
589 int columnCount = 0;
590 iRet = resultSet->GetColumnCount(columnCount);
591 EXPECT_EQ(4, columnCount);
592 iRet = resultSet->GetString(columnCount, strValue);
593 EXPECT_NE(E_OK, iRet);
594
595 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
596 iRet = resultSet->GetString(0, strValue);
597 EXPECT_EQ(E_OK, iRet);
598 EXPECT_EQ("2", strValue);
599 iRet = resultSet->GetString(1, strValue);
600 EXPECT_EQ(E_OK, iRet);
601 EXPECT_EQ("-5", strValue);
602 iRet = resultSet->GetString(2, strValue);
603 EXPECT_EQ(E_OK, iRet);
604 EXPECT_EQ("2.5", strValue);
605 }
606
607 /* *
608 * @tc.name: RdbStore_StepResultSet_011
609 * @tc.desc: normal testcase of StepResultSet for GetDouble
610 * @tc.type: FUNC
611 * @tc.require: AR000FKD4F
612 */
613 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_011, TestSize.Level1)
614 {
615 GenerateDefaultTable();
616 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
617 EXPECT_NE(resultSet, nullptr);
618
619 double dValue;
620 int iRet = resultSet->GetDouble(0, dValue);
621 EXPECT_NE(E_OK, iRet);
622
623 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
624 iRet = resultSet->GetDouble(0, dValue);
625 EXPECT_EQ(E_OK, iRet);
626 EXPECT_EQ(0.0, dValue);
627 iRet = resultSet->GetDouble(1, dValue);
628 EXPECT_EQ(E_OK, iRet);
629 EXPECT_EQ(10.0, dValue);
630
631 iRet = resultSet->GetDouble(2, dValue);
632 EXPECT_EQ(E_OK, iRet);
633 EXPECT_EQ(1.0, dValue);
634
635 iRet = resultSet->GetDouble(3, dValue);
636 EXPECT_EQ(E_OK, iRet);
637 int columnCount = 0;
638 iRet = resultSet->GetColumnCount(columnCount);
639 EXPECT_EQ(4, columnCount);
640 iRet = resultSet->GetDouble(columnCount, dValue);
641 EXPECT_NE(E_OK, iRet);
642
643 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
644 iRet = resultSet->GetDouble(0, dValue);
645 EXPECT_EQ(E_OK, iRet);
646 EXPECT_EQ(2.0, dValue);
647 iRet = resultSet->GetDouble(1, dValue);
648 EXPECT_EQ(E_OK, iRet);
649 EXPECT_EQ(-5.0, dValue);
650 iRet = resultSet->GetDouble(2, dValue);
651 EXPECT_EQ(E_OK, iRet);
652 EXPECT_EQ(2.5, dValue);
653 }
654
655 /* *
656 * @tc.name: RdbStore_StepResultSet_012
657 * @tc.desc: normal testcase of StepResultSet for getBlob
658 * @tc.type: FUNC
659 * @tc.require: AR000FKD4F
660 */
661 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_012, TestSize.Level1)
662 {
663 GenerateDefaultTable();
664 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
665 EXPECT_NE(resultSet, nullptr);
666
667 std::vector<uint8_t> blobValue;
668 int iRet = resultSet->GetBlob(0, blobValue);
669 EXPECT_NE(E_OK, iRet);
670
671 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
672 iRet = resultSet->GetBlob(0, blobValue);
673 EXPECT_EQ(E_OK, iRet);
674
675 string strBlob;
676 for (size_t i = 0; i < blobValue.size(); i++) {
677 strBlob += char(blobValue[i]);
678 }
679 EXPECT_EQ("hello", strBlob);
680
681 iRet = resultSet->GetBlob(1, blobValue);
682 EXPECT_EQ(E_OK, iRet);
683
684 iRet = resultSet->GetBlob(2, blobValue);
685 EXPECT_EQ(E_OK, iRet);
686
687 iRet = resultSet->GetBlob(3, blobValue);
688 EXPECT_EQ(E_OK, iRet);
689
690 strBlob.clear();
691 for (size_t i = 0; i < blobValue.size(); i++) {
692 strBlob += char(blobValue[i]);
693 }
694 char cValue = 66;
695 string strTmpValue(1, cValue);
696 EXPECT_EQ(strTmpValue, strBlob);
697
698 int columnCount = 0;
699 iRet = resultSet->GetColumnCount(columnCount);
700 EXPECT_EQ(4, columnCount);
701 iRet = resultSet->GetBlob(columnCount, blobValue);
702 EXPECT_NE(E_OK, iRet);
703
704 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
705 iRet = resultSet->GetBlob(3, blobValue);
706 EXPECT_EQ(E_OK, iRet);
707 }
708
709 /* *
710 * @tc.name: RdbStore_StepResultSet_013
711 * @tc.desc: normal testcase of StepResultSet for getBlob
712 * @tc.type: FUNC
713 * @tc.require: AR000FKD4F
714 */
715 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_013, TestSize.Level1)
716 {
717 GenerateDefaultTable();
718 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
719 EXPECT_NE(resultSet, nullptr);
720
721 ColumnType type;
722 int iRet = resultSet->GetColumnType(0, type);
723 EXPECT_NE(E_OK, iRet);
724
725 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
726 CheckColumnType(resultSet, 0, ColumnType::TYPE_INTEGER);
727
728 CheckColumnType(resultSet, 1, ColumnType::TYPE_STRING);
729
730 CheckColumnType(resultSet, 2, ColumnType::TYPE_INTEGER);
731
732 CheckColumnType(resultSet, 3, ColumnType::TYPE_FLOAT);
733
734 CheckColumnType(resultSet, 4, ColumnType::TYPE_BLOB);
735
736 int columnCount = 0;
737 iRet = resultSet->GetColumnCount(columnCount);
738 EXPECT_EQ(5, columnCount);
739 iRet = resultSet->GetColumnType(columnCount, type);
740 EXPECT_NE(E_OK, iRet);
741 }
742
743 /* *
744 * @tc.name: RdbStore_StepResultSet_014
745 * @tc.desc: normal testcase of StepResultSet for getColumnIndexForName
746 * @tc.type: FUNC
747 * @tc.require: AR000FKD4F
748 */
749 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_014, TestSize.Level1)
750 {
751 GenerateDefaultTable();
752 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
753 EXPECT_NE(resultSet, nullptr);
754
755 int columnIndex;
756 int iRet = resultSet->GetColumnIndex("data1", columnIndex);
757 EXPECT_EQ(E_OK, iRet);
758 EXPECT_EQ(1, columnIndex);
759
760 iRet = resultSet->GetColumnIndex("data2", columnIndex);
761 EXPECT_EQ(E_OK, iRet);
762 EXPECT_EQ(2, columnIndex);
763
764 iRet = resultSet->GetColumnIndex("data3", columnIndex);
765 EXPECT_EQ(E_OK, iRet);
766 EXPECT_EQ(3, columnIndex);
767
768 iRet = resultSet->GetColumnIndex("data4", columnIndex);
769 EXPECT_EQ(E_OK, iRet);
770 EXPECT_EQ(4, columnIndex);
771
772 iRet = resultSet->GetColumnIndex("jank.data1", columnIndex);
773 EXPECT_EQ(E_OK, iRet);
774 EXPECT_EQ(1, columnIndex);
775
776 iRet = resultSet->GetColumnIndex("datax", columnIndex);
777 EXPECT_EQ(E_ERROR, iRet);
778 EXPECT_EQ(-1, columnIndex);
779 }
780
781 /* *
782 * @tc.name: RdbStore_StepResultSet_015
783 * @tc.desc: normal testcase of StepResultSet for getColumnNameForIndex
784 * @tc.type: FUNC
785 * @tc.require: AR000FKD4F
786 */
787 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_015, TestSize.Level1)
788 {
789 GenerateDefaultTable();
790 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
791 EXPECT_NE(resultSet, nullptr);
792
793 std::vector<std::string> allColumnNames;
794 int iRet = resultSet->GetAllColumnNames(allColumnNames);
795 EXPECT_EQ(E_OK, iRet);
796
797 std::string columnName;
798 iRet = resultSet->GetColumnName(1, columnName);
799 EXPECT_EQ("data1", columnName);
800 EXPECT_EQ(allColumnNames[1], columnName);
801
802 iRet = resultSet->GetColumnName(2, columnName);
803 EXPECT_EQ("data2", columnName);
804 EXPECT_EQ(allColumnNames[2], columnName);
805
806 iRet = resultSet->GetColumnName(3, columnName);
807 EXPECT_EQ("data3", columnName);
808 EXPECT_EQ(allColumnNames[3], columnName);
809
810 iRet = resultSet->GetColumnName(4, columnName);
811 EXPECT_EQ("data4", columnName);
812 EXPECT_EQ(allColumnNames[4], columnName);
813
814 int columnCount = 0;
815 iRet = resultSet->GetColumnCount(columnCount);
816 EXPECT_EQ(5, columnCount);
817 iRet = resultSet->GetColumnName(columnCount, columnName);
818 EXPECT_NE(E_OK, iRet);
819 }
820
821 /* *
822 * @tc.name: RdbStore_StepResultSet_016
823 * @tc.desc: normal testcase of StepResultSet
824 * @tc.type: FUNC
825 * @tc.require: AR000FKD4F
826 */
827 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_016, TestSize.Level1)
828 {
829 GenerateDefaultTable();
830 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
831 EXPECT_NE(resultSet, nullptr);
832
833 bool bResultSet = false;
834 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
835 int iRet = resultSet->IsAtFirstRow(bResultSet);
836 EXPECT_EQ(E_OK, iRet);
837 EXPECT_EQ(bResultSet, true);
838
839 bResultSet = false;
840 iRet = resultSet->IsStarted(bResultSet);
841 EXPECT_EQ(E_OK, iRet);
842 EXPECT_EQ(bResultSet, true);
843
844 int iValue;
845 iRet = resultSet->GetInt(1, iValue);
846 EXPECT_EQ(E_OK, iRet);
847 EXPECT_EQ(10, iValue);
848
849 int64_t longValue;
850 iRet = resultSet->GetLong(1, longValue);
851 EXPECT_EQ(E_OK, iRet);
852 EXPECT_EQ(10, longValue);
853 }
854
855 /* *
856 * @tc.name: RdbStore_StepResultSet_017
857 * @tc.desc: Abnormal testcase of StepResultSet, arguments of GetAsset and GetAssets are invalid
858 * @tc.type: FUNC
859 * @tc.require: AR000FKD4F
860 */
861 HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_017, TestSize.Level1)
862 {
863 GenerateDefaultTable();
864 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
865 EXPECT_NE(resultSet, nullptr);
866 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
867
868 ValueObject::Asset asset;
869 // if columnIndex < 0
870 EXPECT_EQ(E_COLUMN_OUT_RANGE, resultSet->GetAsset(-1, asset));
871 ValueObject::Assets assets;
872 EXPECT_EQ(E_COLUMN_OUT_RANGE, resultSet->GetAssets(-1, assets));
873 }
874
875 /* *
876 * @tc.name: testGetRowCount003
877 * @tc.desc: normal testcase of StepResultSet for getRowCount
878 * @tc.type: FUNC
879 * @tc.require: AR000FKD4F
880 */
881 HWTEST_F(RdbStepResultSetTest, testGetRowCount003, TestSize.Level1)
882 {
883 GenerateDefaultTable();
884 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
885 EXPECT_NE(resultSet, nullptr);
886
887 bool bResultSet = true;
888 int iRet = resultSet->IsStarted(bResultSet);
889 EXPECT_EQ(E_OK, iRet);
890 EXPECT_EQ(bResultSet, false);
891
892 int count = -1;
893 iRet = resultSet->GetRowCount(count);
894 EXPECT_EQ(E_OK, iRet);
895 EXPECT_EQ(3, count);
896 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
897
898 bResultSet = false;
899 EXPECT_EQ(E_OK, resultSet->IsAtFirstRow(bResultSet));
900 EXPECT_EQ(bResultSet, true);
901
902 CheckResultSetData(1, resultSet, g_resultSetData[1]);
903
904 iRet = resultSet->GetRowCount(count);
905 EXPECT_EQ(E_OK, iRet);
906 EXPECT_EQ(3, count);
907
908 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
909 int position = INT_MIN;
910 iRet = resultSet->GetRowIndex(position);
911 EXPECT_EQ(E_OK, iRet);
912 EXPECT_EQ(1, position);
913
914 CheckResultSetData(1, resultSet, g_resultSetData[0]);
915
916 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
917 iRet = resultSet->GetRowIndex(position);
918 EXPECT_EQ(E_OK, iRet);
919 EXPECT_EQ(2, position);
920
921 iRet = resultSet->GetRowCount(count);
922 EXPECT_EQ(E_OK, iRet);
923 EXPECT_EQ(3, count);
924 }
925
926 /* *
927 * @tc.name: testGetRowCount004
928 * @tc.desc: normal testcase of StepResultSet for getRowCount
929 * @tc.type: FUNC
930 * @tc.require: AR000FKD4F
931 */
932 HWTEST_F(RdbStepResultSetTest, testGetRowCount004, TestSize.Level1)
933 {
934 GenerateDefaultTable();
935 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
936 EXPECT_NE(resultSet, nullptr);
937
938 bool bResultSet = true;
939 int iRet = resultSet->IsStarted(bResultSet);
940 EXPECT_EQ(E_OK, iRet);
941 EXPECT_EQ(bResultSet, false);
942 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
943
944 bResultSet = false;
945 iRet = resultSet->IsAtFirstRow(bResultSet);
946 EXPECT_EQ(E_OK, iRet);
947 EXPECT_EQ(bResultSet, true);
948
949 int count = -1;
950 iRet = resultSet->GetRowCount(count);
951 EXPECT_EQ(E_OK, iRet);
952 EXPECT_EQ(3, count);
953
954 CheckResultSetData(0, resultSet, g_resultSetData[1]);
955
956 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
957
958 int position = INT_MIN;
959 iRet = resultSet->GetRowIndex(position);
960 EXPECT_EQ(E_OK, iRet);
961 EXPECT_EQ(1, position);
962
963 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
964
965 iRet = resultSet->GetRowIndex(position);
966 EXPECT_EQ(E_OK, iRet);
967 EXPECT_EQ(2, position);
968
969 iRet = resultSet->GetRowCount(count);
970 EXPECT_EQ(E_OK, iRet);
971 EXPECT_EQ(3, count);
972
973 CheckResultSetData(0, resultSet, g_resultSetData[2]);
974 }
975
976 /* *
977 * @tc.name: testGoToRow005
978 * @tc.desc: normal testcase of StepResultSet for goToRow
979 * @tc.type: FUNC
980 * @tc.require: AR000FKD4F
981 */
982 HWTEST_F(RdbStepResultSetTest, testGoToRow005, TestSize.Level1)
983 {
984 GenerateDefaultTable();
985 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
986 EXPECT_NE(resultSet, nullptr);
987
988 bool bResultSet = true;
989 int iRet = resultSet->IsStarted(bResultSet);
990 EXPECT_EQ(E_OK, iRet);
991 EXPECT_EQ(bResultSet, false);
992 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
993
994 bResultSet = false;
995 iRet = resultSet->IsAtFirstRow(bResultSet);
996 EXPECT_EQ(E_OK, iRet);
997 EXPECT_EQ(bResultSet, true);
998
999 int position = INT_MIN;
1000 iRet = resultSet->GetRowIndex(position);
1001 EXPECT_EQ(E_OK, iRet);
1002 EXPECT_EQ(0, position);
1003
1004 EXPECT_EQ(E_OK, resultSet->GoToRow(2));
1005
1006 iRet = resultSet->GetRowIndex(position);
1007 EXPECT_EQ(E_OK, iRet);
1008 EXPECT_EQ(2, position);
1009
1010 CheckResultSetData(0, resultSet, g_resultSetData[2]);
1011
1012 EXPECT_EQ(E_OK, resultSet->GoToRow(1));
1013
1014 iRet = resultSet->GetRowIndex(position);
1015 EXPECT_EQ(E_OK, iRet);
1016 EXPECT_EQ(1, position);
1017
1018 CheckResultSetData(0, resultSet, g_resultSetData[0]);
1019 }
1020
1021 /* *
1022 * @tc.name: testGo006
1023 * @tc.desc: normal testcase of StepResultSet for goToRow
1024 * @tc.type: FUNC
1025 * @tc.require: AR000FKD4F
1026 */
1027 HWTEST_F(RdbStepResultSetTest, testGo006, TestSize.Level1)
1028 {
1029 GenerateDefaultTable();
1030 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
1031 EXPECT_NE(resultSet, nullptr);
1032 int position = INT_MIN;
1033 int iRet = resultSet->GetRowIndex(position);
1034 EXPECT_EQ(E_OK, iRet);
1035 EXPECT_EQ(-1, position);
1036
1037 int count = -1;
1038 iRet = resultSet->GetRowCount(count);
1039 EXPECT_EQ(E_OK, iRet);
1040 EXPECT_EQ(3, count);
1041
1042 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1043
1044 iRet = resultSet->GetRowIndex(position);
1045 EXPECT_EQ(E_OK, iRet);
1046 EXPECT_EQ(0, position);
1047
1048 EXPECT_EQ(resultSet->GoTo(2), E_OK);
1049
1050 CheckResultSetData(1, resultSet, g_resultSetData[2]);
1051
1052 EXPECT_EQ(resultSet->GoTo(-2), E_OK);
1053
1054 iRet = resultSet->GetRowIndex(position);
1055 EXPECT_EQ(E_OK, iRet);
1056 EXPECT_EQ(0, position);
1057
1058 CheckResultSetData(1, resultSet, g_resultSetData[1]);
1059 }
1060
1061 /* *
1062 * @tc.name: testGoToPrevious007
1063 * @tc.desc: normal testcase of StepResultSet for go
1064 * @tc.type: FUNC
1065 * @tc.require: AR000FKD4F
1066 */
1067 HWTEST_F(RdbStepResultSetTest, testGoToPrevious007, TestSize.Level1)
1068 {
1069 GenerateDefaultTable();
1070 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1071 EXPECT_NE(resultSet, nullptr);
1072
1073 int count = -1;
1074 int iRet = resultSet->GetRowCount(count);
1075 EXPECT_EQ(E_OK, iRet);
1076 EXPECT_EQ(3, count);
1077
1078 bool bResultSet = true;
1079 iRet = resultSet->IsStarted(bResultSet);
1080 EXPECT_EQ(E_OK, iRet);
1081 EXPECT_EQ(bResultSet, false);
1082
1083 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1084
1085 bResultSet = false;
1086 iRet = resultSet->IsAtFirstRow(bResultSet);
1087 EXPECT_EQ(E_OK, iRet);
1088 EXPECT_EQ(bResultSet, true);
1089
1090 CheckResultSetData(0, resultSet, g_resultSetData[1]);
1091
1092 int ret = resultSet->GoToPreviousRow();
1093 EXPECT_NE(E_OK, ret);
1094
1095 CheckResultSetAttribute(resultSet, 0, true, true, false);
1096
1097 EXPECT_EQ(resultSet->GoTo(1), E_OK);
1098
1099 CheckResultSetData(0, resultSet, g_resultSetData[0]);
1100
1101 EXPECT_EQ(E_OK, resultSet->GoToLastRow());
1102
1103 iRet = resultSet->IsAtLastRow(bResultSet);
1104 EXPECT_EQ(E_OK, iRet);
1105 EXPECT_EQ(true, bResultSet);
1106
1107 EXPECT_EQ(E_OK, resultSet->GoToPreviousRow());
1108
1109 int position = INT_MIN;
1110 iRet = resultSet->GetRowIndex(position);
1111 EXPECT_EQ(E_OK, iRet);
1112 EXPECT_EQ(1, position);
1113
1114 EXPECT_NE(E_OK, resultSet->GoTo(3));
1115
1116 CheckResultSetAttribute(resultSet, 3, true, false, true);
1117 }
1118
1119 /* *
1120 * @tc.name: testSqlStep008
1121 * @tc.desc: normal testcase of SqlStep for go
1122 * @tc.type: FUNC
1123 * @tc.require: AR000FKD4F
1124 */
1125 HWTEST_F(RdbStepResultSetTest, testSqlStep008, TestSize.Level1)
1126 {
1127 GenerateDefaultTable();
1128 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1129 EXPECT_NE(resultSet, nullptr);
1130
1131 bool bResultSet = true;
1132 int iRet = resultSet->IsStarted(bResultSet);
1133 EXPECT_EQ(E_OK, iRet);
1134 EXPECT_EQ(bResultSet, false);
1135
1136 EXPECT_EQ(E_OK, resultSet->GoTo(1));
1137
1138 bResultSet = false;
1139 iRet = resultSet->IsAtFirstRow(bResultSet);
1140 EXPECT_EQ(E_OK, iRet);
1141 EXPECT_EQ(bResultSet, true);
1142
1143 CheckColumnType(resultSet, 0, ColumnType::TYPE_STRING);
1144
1145 CheckColumnType(resultSet, 1, ColumnType::TYPE_INTEGER);
1146
1147 CheckColumnType(resultSet, 2, ColumnType::TYPE_FLOAT);
1148
1149 CheckColumnType(resultSet, 3, ColumnType::TYPE_BLOB);
1150
1151 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1152 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
1153
1154 int position = INT_MIN;
1155 iRet = resultSet->GetRowIndex(position);
1156 EXPECT_EQ(E_OK, iRet);
1157 EXPECT_EQ(1, position);
1158
1159 int count = -1;
1160 iRet = resultSet->GetRowCount(count);
1161 EXPECT_EQ(E_OK, iRet);
1162 EXPECT_EQ(3, count);
1163
1164 CheckResultSetData(0, resultSet, g_resultSetData[0]);
1165 }
1166
1167 /* *
1168 * @tc.name: testSqlStep009
1169 * @tc.desc: normal testcase of SqlStep for go
1170 * @tc.type: FUNC
1171 * @tc.require: AR000FKD4F
1172 */
1173 HWTEST_F(RdbStepResultSetTest, testSqlStep009, TestSize.Level1)
1174 {
1175 GenerateDefaultTable();
1176 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1177 EXPECT_NE(resultSet, nullptr);
1178
1179 int count = -1;
1180 int iRet = resultSet->GetRowCount(count);
1181 EXPECT_EQ(E_OK, iRet);
1182 EXPECT_EQ(3, count);
1183
1184 int position = INT_MIN;
1185 iRet = resultSet->GetRowIndex(position);
1186 EXPECT_EQ(E_OK, iRet);
1187 EXPECT_EQ(-1, position);
1188
1189 bool bResultSet = true;
1190 iRet = resultSet->IsAtFirstRow(bResultSet);
1191 EXPECT_EQ(E_OK, iRet);
1192 EXPECT_EQ(bResultSet, false);
1193
1194 EXPECT_EQ(E_OK, resultSet->GoToRow(2));
1195
1196 bResultSet = false;
1197 iRet = resultSet->IsAtLastRow(bResultSet);
1198 EXPECT_EQ(E_OK, iRet);
1199 EXPECT_EQ(true, bResultSet);
1200
1201 EXPECT_EQ(E_OK, resultSet->GoToPreviousRow());
1202
1203 iRet = resultSet->GetRowIndex(position);
1204 EXPECT_EQ(E_OK, iRet);
1205 EXPECT_EQ(1, position);
1206
1207 EXPECT_EQ(E_OK, resultSet->GoToLastRow());
1208
1209 bResultSet = false;
1210 iRet = resultSet->IsAtLastRow(bResultSet);
1211 EXPECT_EQ(E_OK, iRet);
1212 EXPECT_EQ(true, bResultSet);
1213
1214 bResultSet = false;
1215 iRet = resultSet->IsAtLastRow(bResultSet);
1216 EXPECT_EQ(E_OK, iRet);
1217 EXPECT_EQ(true, bResultSet);
1218
1219 bResultSet = false;
1220 iRet = resultSet->IsStarted(bResultSet);
1221 EXPECT_EQ(E_OK, iRet);
1222 EXPECT_EQ(bResultSet, true);
1223
1224 bResultSet = true;
1225 iRet = resultSet->IsEnded(bResultSet);
1226 EXPECT_EQ(E_OK, iRet);
1227 EXPECT_EQ(bResultSet, false);
1228 }
1229
1230 /* *
1231 * @tc.name: testSqlStep010
1232 * @tc.desc: normal testcase of SqlStep for go
1233 * @tc.type: FUNC
1234 * @tc.require: AR000FKD4F
1235 */
1236 HWTEST_F(RdbStepResultSetTest, testSqlStep010, TestSize.Level1)
1237 {
1238 GenerateDefaultTable();
1239 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1240 EXPECT_NE(resultSet, nullptr);
1241
1242 CheckResultSetAttribute(resultSet, -1, false, false, false);
1243
1244 int moveTimes = 0;
1245 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
1246 moveTimes++;
1247
1248 CheckResultSetAttribute(resultSet, 0, true, true, false);
1249
1250 while (E_OK == resultSet->GoToNextRow()) {
1251 moveTimes++;
1252 }
1253
1254 CheckResultSetAttribute(resultSet, 3, true, false, true);
1255 }
1256
1257 /* *
1258 * @tc.name: testSqlStep011
1259 * @tc.desc: normal testcase of SqlStep for GetString()
1260 * @tc.type: FUNC
1261 * @tc.require: NA
1262 */
1263 HWTEST_F(RdbStepResultSetTest, testSqlStep011, TestSize.Level1)
1264 {
1265 GenerateDefaultEmptyTable();
1266
1267 std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
1268 const char arr[] = { 0X11, 0X22, 0X33, 0X44, 0X55, 0X00, 0X66, 0X77, 0X00 };
1269 size_t arrLen = sizeof(arr);
1270 uint8_t uValue = 66;
1271 std::vector<uint8_t> typeBlob;
1272 typeBlob.push_back(uValue);
1273 store->ExecuteSql(insertSql, std::vector<ValueObject>{ ValueObject(std::string(arr, arrLen)), ValueObject((int)10),
1274 ValueObject((double)1.0), ValueObject((std::vector<uint8_t>)typeBlob) });
1275 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
1276 EXPECT_NE(resultSet, nullptr);
1277
1278 int iRet = resultSet->GoToFirstRow();
1279 EXPECT_EQ(E_OK, iRet);
1280 bool bResultSet = false;
1281 iRet = resultSet->IsAtFirstRow(bResultSet);
1282 EXPECT_EQ(E_OK, iRet);
1283 EXPECT_EQ(bResultSet, true);
1284
1285 std::string stringValue;
1286 iRet = resultSet->GetString(0, stringValue);
1287 size_t stringValueLen = stringValue.length();
1288 EXPECT_EQ(E_OK, iRet);
1289 EXPECT_EQ(arrLen, stringValueLen);
1290 }
1291
1292 /* *
1293 * @tc.name: testSqlStep012
1294 * @tc.desc: Normal testcase of SqlStep for constructor std::vector<ValueObject>
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(RdbStepResultSetTest, testSqlStep012, TestSize.Level1)
1298 {
1299 GenerateDefaultEmptyTable();
1300
1301 std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
1302 const char arr[] = { 0X11, 0X22, 0X33, 0X44, 0X55, 0X00, 0X66, 0X77, 0X00 };
1303 size_t arrLen = sizeof(arr);
1304 uint8_t uValue = 66;
1305 std::vector<uint8_t> typeBlob;
1306 typeBlob.push_back(uValue);
1307 store->ExecuteSql(insertSql, std::vector<ValueObject>{ ValueObject(std::string(arr, arrLen)), ValueObject((int)10),
1308 ValueObject((double)1.0), ValueObject((std::vector<uint8_t>)typeBlob) });
1309
1310 std::shared_ptr<ResultSet> resultSet =
1311 store->QueryByStep("SELECT ? FROM test", std::vector<ValueObject>{ ValueObject((std::string) "data1") });
1312 EXPECT_NE(resultSet, nullptr);
1313
1314 int iRet = resultSet->GoToFirstRow();
1315 EXPECT_EQ(E_OK, iRet);
1316 bool bResultSet = false;
1317 iRet = resultSet->IsAtFirstRow(bResultSet);
1318 EXPECT_EQ(E_OK, iRet);
1319 EXPECT_EQ(bResultSet, true);
1320
1321 EXPECT_EQ(E_OK, resultSet->Close());
1322 }
1323
1324 /* *
1325 * @tc.name: testSqlStep013
1326 * @tc.desc: Abnormal testcase of SqlStep, if close resultSet before query
1327 * @tc.type: FUNC
1328 */
1329 HWTEST_F(RdbStepResultSetTest, testSqlStep013, TestSize.Level1)
1330 {
1331 GenerateDefaultTable();
1332
1333 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
1334 EXPECT_NE(resultSet, nullptr);
1335
1336 EXPECT_EQ(E_OK, resultSet->Close());
1337
1338 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToNextRow());
1339
1340 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToLastRow());
1341
1342 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToPreviousRow());
1343
1344 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToFirstRow());
1345
1346 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToRow(1));
1347
1348 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToLastRow());
1349
1350 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToPreviousRow());
1351
1352 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToFirstRow());
1353
1354 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToRow(1));
1355
1356 std::vector<std::string> columnNames;
1357 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetAllColumnNames(columnNames));
1358
1359 ColumnType columnType;
1360 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetColumnType(1, columnType));
1361
1362 std::vector<uint8_t> blob;
1363 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetBlob(1, blob));
1364
1365 std::string valueString;
1366 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetString(1, valueString));
1367
1368 int valueInt;
1369 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetInt(1, valueInt));
1370
1371 int64_t valueInt64;
1372 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetLong(1, valueInt64));
1373
1374 double valuedouble;
1375 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetDouble(1, valuedouble));
1376
1377 ValueObject object;
1378 EXPECT_EQ(E_ALREADY_CLOSED, resultSet->Get(4, object));
1379 }
1380
1381 /* *
1382 * @tc.name: testSqlStep014
1383 * @tc.desc: Abnormal testcase of SqlStep for GoToRow, if connection counts over limit
1384 * @tc.type: FUNC
1385 */
1386 HWTEST_F(RdbStepResultSetTest, testSqlStep014, TestSize.Level1)
1387 {
1388 GenerateDefaultTable();
1389
1390 std::shared_ptr<ResultSet> resultSet1 = store->QueryByStep("SELECT * FROM test");
1391 EXPECT_NE(resultSet1, nullptr);
1392
1393 std::shared_ptr<ResultSet> resultSet2 = store->QueryByStep("SELECT * FROM test");
1394 EXPECT_NE(resultSet2, nullptr);
1395
1396 std::shared_ptr<ResultSet> resultSet3 = store->QueryByStep("SELECT * FROM test");
1397 EXPECT_NE(resultSet2, nullptr);
1398
1399 std::shared_ptr<ResultSet> resultSet4 = store->QueryByStep("SELECT * FROM test");
1400 EXPECT_NE(resultSet2, nullptr);
1401
1402 std::shared_ptr<ResultSet> resultSet5 = store->QueryByStep("SELECT * FROM test");
1403 EXPECT_NE(resultSet2, nullptr);
1404
1405 EXPECT_EQ(E_OK, resultSet5->GoToRow(1));
1406
1407 EXPECT_EQ(E_OK, resultSet1->Close());
1408
1409 EXPECT_EQ(E_OK, resultSet5->GoToRow(1));
1410
1411 EXPECT_EQ(E_OK, resultSet2->Close());
1412 EXPECT_EQ(E_OK, resultSet3->Close());
1413 EXPECT_EQ(E_OK, resultSet4->Close());
1414 EXPECT_EQ(E_OK, resultSet5->Close());
1415 }
1416
1417 /* *
1418 * @tc.name: testSqlStep015
1419 * @tc.desc: Abnormal testcase of SqlStep for QueryByStep, if sql is inValid
1420 * @tc.type: FUNC
1421 */
1422 HWTEST_F(RdbStepResultSetTest, testSqlStep015, TestSize.Level1)
1423 {
1424 GenerateDefaultTable();
1425
1426 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SE");
1427 EXPECT_NE(resultSet, nullptr);
1428
1429 std::vector<std::string> columnNames;
1430 EXPECT_EQ(E_INVALID_ARGS, resultSet->GetAllColumnNames(columnNames));
1431
1432 EXPECT_EQ(E_OK, resultSet->Close());
1433 }
1434
1435 /* *
1436 * @tc.name: testSqlStep016
1437 * @tc.desc: Abnormal testcase of SqlStep for GetSize, if rowPos is inValid
1438 * @tc.type: FUNC
1439 */
1440 HWTEST_F(RdbStepResultSetTest, testSqlStep016, TestSize.Level1)
1441 {
1442 GenerateDefaultTable();
1443
1444 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SE");
1445 EXPECT_NE(resultSet, nullptr);
1446
1447 size_t size;
1448 EXPECT_EQ(E_ROW_OUT_RANGE, resultSet->GetSize(2, size));
1449
1450 EXPECT_EQ(E_OK, resultSet->Close());
1451 EXPECT_EQ(true, resultSet->IsClosed());
1452 }
1453
1454 /* *
1455 * @tc.name: testSqlStep017
1456 * @tc.desc: Abnormal testcase for build query string
1457 * @tc.type: FUNC
1458 */
1459 HWTEST_F(RdbStepResultSetTest, testSqlStep017, TestSize.Level1)
1460 {
1461 std::vector<std::string> columns = { "data1", "data2" };
1462
1463 std::string outSql;
1464 int errCode = SqliteSqlBuilder::BuildQueryString(false, "", "", columns, "", "", "", "", 0, 0, outSql);
1465 EXPECT_EQ(E_EMPTY_TABLE_NAME, errCode);
1466 }
1467
1468 /* *
1469 * @tc.name: testSqlStep018
1470 * @tc.desc: Abnormal testcase for build query string
1471 * @tc.type: FUNC
1472 */
1473 HWTEST_F(RdbStepResultSetTest, testSqlStep018, TestSize.Level1)
1474 {
1475 AbsRdbPredicates predicates("test");
1476 std::vector<std::string> columns;
1477 std::string logTable = "naturalbase_rdb_aux_test_log";
1478 std::string sqlstr;
1479 std::pair<bool, bool> queryStatus = { false, false };
1480
1481 // logtable is empty && tableName is not empty
1482 queryStatus = { false, true };
1483 sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, "", queryStatus);
1484 EXPECT_EQ("", sqlstr);
1485
1486 // logtable is empty && tableName is empty
1487 AbsRdbPredicates emptyPredicates("");
1488 std::string tableName = emptyPredicates.GetTableName();
1489 EXPECT_EQ("", tableName);
1490 sqlstr = SqliteSqlBuilder::BuildCursorQueryString(emptyPredicates, columns, "", queryStatus);
1491 EXPECT_EQ("", sqlstr);
1492
1493 // logtable is not empty && tableName is empty
1494 sqlstr = SqliteSqlBuilder::BuildCursorQueryString(emptyPredicates, columns, logTable, queryStatus);
1495 EXPECT_EQ("", sqlstr);
1496
1497 // Distinct is false, clumns is empty
1498 sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, logTable, queryStatus);
1499 std::string value = "SELECT test.*, naturalbase_rdb_aux_test_log.cursor, CASE "
1500 "WHEN naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 "
1501 "THEN true ELSE false END AS deleted_flag, CASE "
1502 "WHEN naturalbase_rdb_aux_test_log.flag & 0x808 = 0x808 THEN 3 WHEN "
1503 "naturalbase_rdb_aux_test_log.flag & 0x800 = 0x800 THEN 1 WHEN "
1504 "naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 THEN 2 ELSE 0 END AS data_status "
1505 "FROM test INNER JOIN naturalbase_rdb_aux_test_log "
1506 "ON test.ROWID = naturalbase_rdb_aux_test_log.data_key";
1507 EXPECT_EQ(value, sqlstr);
1508
1509 // Distinct is true, clumns is not empty
1510 predicates.Distinct();
1511 columns.push_back("name");
1512 sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, logTable, queryStatus);
1513 value = "SELECT DISTINCT test.name, naturalbase_rdb_aux_test_log.cursor, CASE "
1514 "WHEN naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 "
1515 "THEN true ELSE false END AS deleted_flag, CASE "
1516 "WHEN naturalbase_rdb_aux_test_log.flag & 0x808 = 0x808 THEN 3 WHEN "
1517 "naturalbase_rdb_aux_test_log.flag & 0x800 = 0x800 THEN 1 WHEN "
1518 "naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 THEN 2 ELSE 0 END AS data_status "
1519 "FROM test INNER JOIN naturalbase_rdb_aux_test_log "
1520 "ON test.ROWID = naturalbase_rdb_aux_test_log.data_key";
1521 EXPECT_EQ(value, sqlstr);
1522 }
1523
1524 /* *
1525 * @tc.name: testSqlStep019
1526 * @tc.desc: Abnormal testcase for build query string
1527 * @tc.type: FUNC
1528 */
1529 HWTEST_F(RdbStepResultSetTest, testSqlStep019, TestSize.Level1)
1530 {
1531 AbsRdbPredicates predicates("test");
1532 std::vector<std::string> columns;
1533 std::string logTable = "naturalbase_rdb_aux_test_log";
1534 std::string sqlstr;
1535 std::pair<bool, bool> queryStatus = { true, false };
1536
1537 //Distinct is false, columns has spacial field
1538 queryStatus = { true, false };
1539 columns.push_back("name");
1540 columns.push_back("#_sharing_resource_field");
1541 sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, logTable, queryStatus);
1542 std::string value = "SELECT test.name, naturalbase_rdb_aux_test_log.sharing_resource AS sharing_resource_field"
1543 " FROM test INNER JOIN naturalbase_rdb_aux_test_log "
1544 "ON test.ROWID = naturalbase_rdb_aux_test_log.data_key";
1545 EXPECT_EQ(value, sqlstr);
1546
1547 //Distinct is true, columns has spacial field
1548 predicates.Distinct();
1549 sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, logTable, queryStatus);
1550 value = "SELECT DISTINCT test.name, naturalbase_rdb_aux_test_log.sharing_resource AS sharing_resource_field"
1551 " FROM test INNER JOIN naturalbase_rdb_aux_test_log "
1552 "ON test.ROWID = naturalbase_rdb_aux_test_log.data_key";
1553 EXPECT_EQ(value, sqlstr);
1554
1555 //Distinct is true, columns and predicates have spacial fields
1556 queryStatus = { true, true };
1557 sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, logTable, queryStatus);
1558 value = "SELECT DISTINCT test.name, naturalbase_rdb_aux_test_log.sharing_resource AS sharing_resource_field, "
1559 "naturalbase_rdb_aux_test_log.cursor, CASE "
1560 "WHEN naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 "
1561 "THEN true ELSE false END AS deleted_flag, CASE "
1562 "WHEN naturalbase_rdb_aux_test_log.flag & 0x808 = 0x808 THEN 3 WHEN "
1563 "naturalbase_rdb_aux_test_log.flag & 0x800 = 0x800 THEN 1 WHEN "
1564 "naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 THEN 2 ELSE 0 END AS data_status "
1565 "FROM test INNER JOIN naturalbase_rdb_aux_test_log "
1566 "ON test.ROWID = naturalbase_rdb_aux_test_log.data_key";
1567 EXPECT_EQ(value, sqlstr);
1568 }
1569
1570 /* *
1571 * @tc.name: testSqlStep020
1572 * @tc.desc: normal testcase of SqlStep for QueryByStep, if sql is WITH
1573 * @tc.type: FUNC
1574 */
1575 HWTEST_F(RdbStepResultSetTest, testSqlStep020, TestSize.Level1)
1576 {
1577 GenerateDefaultTable();
1578
1579 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("WITH tem AS ( SELECT * FROM test) SELECT * FROM tem");
1580 EXPECT_NE(nullptr, resultSet);
1581
1582 std::vector<std::string> allColumnNames;
1583 int ret = resultSet->GetAllColumnNames(allColumnNames);
1584 EXPECT_EQ(E_OK, ret);
1585
1586 std::string columnName;
1587 ret = resultSet->GetColumnName(1, columnName);
1588 EXPECT_EQ("data1", columnName);
1589 EXPECT_EQ(allColumnNames[1], columnName);
1590
1591 ret = resultSet->GetColumnName(2, columnName);
1592 EXPECT_EQ("data2", columnName);
1593 EXPECT_EQ(allColumnNames[2], columnName);
1594
1595 ret = resultSet->GetColumnName(3, columnName);
1596 EXPECT_EQ("data3", columnName);
1597 EXPECT_EQ(allColumnNames[3], columnName);
1598
1599 ret = resultSet->GetColumnName(4, columnName);
1600 EXPECT_EQ("data4", columnName);
1601 EXPECT_EQ(allColumnNames[4], columnName);
1602
1603 int columnCount = 0;
1604 ret = resultSet->GetColumnCount(columnCount);
1605 EXPECT_EQ(5, columnCount);
1606 ret = resultSet->GetColumnName(columnCount, columnName);
1607 EXPECT_NE(E_OK, ret);
1608
1609 EXPECT_EQ(E_OK, resultSet->Close());
1610 }
1611
1612 /* *
1613 * @tc.name: testSqlStep021
1614 * @tc.desc: normal testcase of SqlStep for QueryByStep, PRAGMA user_version
1615 * @tc.type: FUNC
1616 */
1617 HWTEST_F(RdbStepResultSetTest, testSqlStep021, TestSize.Level1)
1618 {
1619 // 2 is used to set the store version
1620 int ret = store->ExecuteSql("PRAGMA user_version = 2");
1621 EXPECT_EQ(ret, E_OK);
1622 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("PRAGMA user_version");
1623
1624 int64_t longValue;
1625 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1626 EXPECT_EQ(E_OK, resultSet->GetLong(0, longValue));
1627 EXPECT_EQ(2, longValue);
1628
1629 resultSet->Close();
1630 }
1631
1632 /* *
1633 * @tc.name: testSqlStep022
1634 * @tc.desc: normal testcase of SqlStep for QueryByStep, PRAGMA table_info
1635 * @tc.type: FUNC
1636 */
1637 HWTEST_F(RdbStepResultSetTest, testSqlStep022, TestSize.Level1)
1638 {
1639 GenerateDefaultEmptyTable();
1640 int ret = store->ExecuteSql("PRAGMA table_info(test)");
1641 EXPECT_EQ(ret, E_OK);
1642 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("PRAGMA table_info(test)");
1643
1644 std::string strValue;
1645 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1646 EXPECT_EQ(E_OK, resultSet->GetString(1, strValue));
1647 EXPECT_EQ("id", strValue);
1648 EXPECT_EQ(E_OK, resultSet->GetString(2, strValue));
1649 EXPECT_EQ("INTEGER", strValue);
1650
1651 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
1652 EXPECT_EQ(E_OK, resultSet->GetString(1, strValue));
1653 EXPECT_EQ("data1", strValue);
1654 EXPECT_EQ(E_OK, resultSet->GetString(2, strValue));
1655 EXPECT_EQ("TEXT", strValue);
1656
1657 resultSet->Close();
1658 }
1659
1660
1661 /* *
1662 * @tc.name: RdbStore_StepResultSet_023
1663 * @tc.desc: normal testcase of StepResultSet
1664 * @tc.type: FUNC
1665 * @tc.require: AR000FKD4F
1666 */
1667 HWTEST_F(RdbStepResultSetTest, testSqlStep023, TestSize.Level1)
1668 {
1669 GenerateDefaultTable();
1670 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test", {}, false);
1671 EXPECT_NE(resultSet, nullptr);
1672
1673 int count = -1;
1674 resultSet->GetRowCount(count);
1675 EXPECT_EQ(3, count);
1676
1677 int position = INT_MIN;
1678 int iRet = resultSet->GetRowIndex(position);
1679 EXPECT_EQ(E_OK, iRet);
1680 EXPECT_EQ(-1, position);
1681
1682 bool bResultSet = true;
1683 resultSet->IsAtFirstRow(bResultSet);
1684 EXPECT_EQ(bResultSet, false);
1685
1686 EXPECT_EQ(E_OK, resultSet->GoToRow(2));
1687
1688 bResultSet = false;
1689 iRet = resultSet->IsAtLastRow(bResultSet);
1690 EXPECT_EQ(E_OK, iRet);
1691 EXPECT_EQ(true, bResultSet);
1692
1693 EXPECT_EQ(E_OK, resultSet->GoToPreviousRow());
1694
1695 iRet = resultSet->GetRowIndex(position);
1696 EXPECT_EQ(E_OK, iRet);
1697 EXPECT_EQ(1, position);
1698
1699 EXPECT_EQ(E_OK, resultSet->GoToLastRow());
1700
1701 bResultSet = false;
1702 iRet = resultSet->IsAtLastRow(bResultSet);
1703 EXPECT_EQ(E_OK, iRet);
1704 EXPECT_EQ(true, bResultSet);
1705
1706 bResultSet = false;
1707 iRet = resultSet->IsStarted(bResultSet);
1708 EXPECT_EQ(E_OK, iRet);
1709 EXPECT_EQ(bResultSet, true);
1710
1711 bResultSet = true;
1712 iRet = resultSet->IsEnded(bResultSet);
1713 EXPECT_EQ(E_OK, iRet);
1714 EXPECT_EQ(bResultSet, false);
1715
1716 resultSet->Close();
1717 }
1718
1719 /* *
1720 * @tc.name: RdbStore_StepResultSet_024
1721 * @tc.desc: normal testcase of StepResultSet for getInt
1722 * @tc.type: FUNC
1723 * @tc.require: AR000FKD4F
1724 */
1725 HWTEST_F(RdbStepResultSetTest, testSqlStep024, TestSize.Level1)
1726 {
1727 GenerateDefaultTable();
1728 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test", {}, false);
1729 EXPECT_NE(resultSet, nullptr);
1730
1731 int iValue;
1732 int iRet = resultSet->GetInt(0, iValue);
1733 EXPECT_NE(E_OK, iRet);
1734
1735 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
1736
1737 iRet = resultSet->GetInt(0, iValue);
1738 EXPECT_EQ(E_OK, iRet);
1739 EXPECT_EQ(0, iValue);
1740
1741 iRet = resultSet->GetInt(1, iValue);
1742 EXPECT_EQ(E_OK, iRet);
1743 EXPECT_EQ(10, iValue);
1744
1745 iRet = resultSet->GetInt(2, iValue);
1746 EXPECT_EQ(E_OK, iRet);
1747 EXPECT_EQ(1, iValue);
1748
1749 iRet = resultSet->GetInt(3, iValue);
1750 EXPECT_EQ(E_OK, iRet);
1751
1752 int columnCount = 0;
1753 iRet = resultSet->GetColumnCount(columnCount);
1754 EXPECT_EQ(4, columnCount);
1755 iRet = resultSet->GetInt(columnCount, iValue);
1756 EXPECT_NE(E_OK, iRet);
1757
1758 EXPECT_EQ(E_OK, resultSet->GoToNextRow());
1759 iRet = resultSet->GetInt(0, iValue);
1760 EXPECT_EQ(E_OK, iRet);
1761 EXPECT_EQ(2, iValue);
1762
1763 int64_t longValue;
1764 iRet = resultSet->GetLong(0, longValue);
1765 EXPECT_EQ(E_OK, iRet);
1766 EXPECT_EQ(2, longValue);
1767
1768 iRet = resultSet->GetInt(1, iValue);
1769 EXPECT_EQ(E_OK, iRet);
1770 EXPECT_EQ(-5, iValue);
1771
1772 iRet = resultSet->GetLong(1, longValue);
1773 EXPECT_EQ(E_OK, iRet);
1774 EXPECT_EQ(-5, longValue);
1775
1776 iRet = resultSet->GetInt(2, iValue);
1777 EXPECT_EQ(E_OK, iRet);
1778 EXPECT_EQ(2, iValue);
1779
1780 resultSet->Close();
1781 }
1782
1783 /**
1784 * @tc.name: ResultSetProxy001
1785 * @tc.desc: Abnormal testcase of distributed ResultSetProxy, if resultSet is Empty
1786 * @tc.type: FUNC
1787 */
1788 HWTEST_F(RdbStepResultSetTest, Abnormal_ResultSetProxy001, TestSize.Level1)
1789 {
1790 int errCode = 0;
1791 auto resultSet = std::make_shared<OHOS::NativeRdb::ResultSetProxy>(nullptr);
1792 ColumnType columnType;
1793 errCode = resultSet->GetColumnType(1, columnType);
1794 EXPECT_NE(E_OK, errCode);
1795
1796 std::string columnName;
1797 errCode = resultSet->GetColumnName(1, columnName);
1798 EXPECT_NE(E_OK, errCode);
1799
1800 std::vector<uint8_t> blob;
1801 errCode = resultSet->GetBlob(1, blob);
1802 EXPECT_NE(E_OK, errCode);
1803
1804 std::string getStringValue;
1805 errCode = resultSet->GetString(1, getStringValue);
1806 EXPECT_NE(E_OK, errCode);
1807
1808 int getIntValue;
1809 errCode = resultSet->GetInt(1, getIntValue);
1810 EXPECT_NE(E_OK, errCode);
1811
1812 int64_t getLongValue;
1813 errCode = resultSet->GetLong(1, getLongValue);
1814 EXPECT_NE(E_OK, errCode);
1815
1816 double getDoubleValue;
1817 errCode = resultSet->GetDouble(1, getDoubleValue);
1818 EXPECT_NE(E_OK, errCode);
1819
1820 bool isNull;
1821 errCode = resultSet->IsColumnNull(1, isNull);
1822 EXPECT_NE(E_OK, errCode);
1823 }
1824
1825 /**
1826 * @tc.name: Normal_CacheResultSet002
1827 * @tc.desc: Normal testcase of CacheResultSet
1828 * @tc.type: FUNC
1829 */
1830 HWTEST_F(RdbStepResultSetTest, Normal_CacheResultSet002, TestSize.Level1)
1831 {
1832 std::vector<OHOS::NativeRdb::ValuesBucket> valueBuckets;
1833 OHOS::NativeRdb::ValuesBucket value1;
1834 value1.PutInt("id", 1);
1835 value1.PutString("name", std::string("zhangsan"));
1836 value1.PutLong("age", 18);
1837 value1.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
1838 valueBuckets.push_back(value1);
1839
1840 OHOS::NativeRdb::ValuesBucket value2;
1841 value2.PutInt("id", 2);
1842 value2.PutString("name", std::string("lisi"));
1843 value2.PutLong("age", 19);
1844 value2.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
1845 valueBuckets.push_back(value2);
1846
1847 std::shared_ptr<OHOS::NativeRdb::CacheResultSet> resultSet =
1848 std::make_shared<CacheResultSet>(std::move(valueBuckets));
1849 int errCode = 0, columnIndex = 0;
1850
1851 int id;
1852 errCode = resultSet->GetColumnIndex("id", columnIndex);
1853 EXPECT_EQ(errCode, E_OK);
1854 EXPECT_EQ(E_OK, resultSet->GetInt(columnIndex, id));
1855 EXPECT_EQ(id, 1);
1856
1857 std::string name;
1858 errCode = resultSet->GetColumnIndex("name", columnIndex);
1859 EXPECT_EQ(errCode, E_OK);
1860 EXPECT_EQ(E_OK, resultSet->GetString(columnIndex, name));
1861 EXPECT_EQ(name, "zhangsan");
1862
1863 int64_t age;
1864 errCode = resultSet->GetColumnIndex("age", columnIndex);
1865 EXPECT_EQ(errCode, E_OK);
1866 EXPECT_EQ(E_OK, resultSet->GetLong(columnIndex, age));
1867 EXPECT_EQ(age, 18);
1868
1869 std::vector<uint8_t> blob;
1870 errCode = resultSet->GetColumnIndex("blobType", columnIndex);
1871 EXPECT_EQ(errCode, E_OK);
1872 EXPECT_EQ(E_OK, resultSet->GetBlob(columnIndex, blob));
1873 EXPECT_EQ(blob.size(), 3);
1874 }
1875
1876 /**
1877 * @tc.name: Abnormal_CacheResultSet005
1878 * @tc.desc: Abnormal testcase of CacheResultSet, if row_ == maxRow_ and
1879 * if position is illegal, and columName is not exist.
1880 * @tc.type: FUNC
1881 */
1882 HWTEST_F(RdbStepResultSetTest, Abnormal_CacheResultSet005, TestSize.Level1)
1883 {
1884 std::vector<OHOS::NativeRdb::ValuesBucket> valueBuckets;
1885 OHOS::NativeRdb::ValuesBucket value1;
1886 value1.PutInt("id", 1);
1887 value1.PutString("name", std::string("zhangsan"));
1888 value1.PutLong("age", 18);
1889 value1.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
1890 valueBuckets.push_back(value1);
1891 std::shared_ptr<OHOS::NativeRdb::CacheResultSet> resultSet =
1892 std::make_shared<CacheResultSet>(std::move(valueBuckets));
1893 int errCode = 0, columnIndex = 0;
1894
1895 // if columnName is not exist
1896 errCode = resultSet->GetColumnIndex("empty", columnIndex);
1897 EXPECT_NE(errCode, E_OK);
1898 // if position < 0
1899 errCode = resultSet->GoToRow(-1);
1900 EXPECT_NE(errCode, E_OK);
1901 //if position > maxRow_
1902 errCode = resultSet->GoToRow(3);
1903 EXPECT_NE(errCode, E_OK);
1904 // if row_ = maxRow_
1905 int id;
1906 errCode = resultSet->GetInt(1, id);
1907 EXPECT_NE(errCode, E_OK);
1908 // if row_ = maxRow_
1909 std::string name;
1910 errCode = resultSet->GetString(2, name);
1911 EXPECT_NE(errCode, E_OK);
1912 // if row_ = maxRow_
1913 int64_t age;
1914 errCode = resultSet->GetLong(3, age);
1915 EXPECT_NE(errCode, E_OK);
1916 // if row_ = maxRow_
1917 std::vector<uint8_t> blob;
1918 errCode = resultSet->GetBlob(4, blob);
1919 EXPECT_NE(errCode, E_OK);
1920 // if row_ = maxRow_
1921 RowEntity rowEntity;
1922 errCode = resultSet->GetRow(rowEntity);
1923 EXPECT_EQ(errCode, E_ERROR);
1924 // if row_ = maxRow_
1925 bool IsNull;
1926 errCode = resultSet->IsColumnNull(1, IsNull);
1927 EXPECT_EQ(errCode, E_ERROR);
1928 // if row_ = maxRow_
1929 ValueObject::Asset asset;
1930 errCode = resultSet->GetAsset(1, asset);
1931 EXPECT_EQ(errCode, E_ERROR);
1932 // if row_ = maxRow_
1933 ValueObject::Assets assets;
1934 errCode = resultSet->GetAssets(1, assets);
1935 EXPECT_EQ(errCode, E_ERROR);
1936 // if row_ = maxRow_
1937 ValueObject value;
1938 errCode = resultSet->Get(1, value);
1939 EXPECT_EQ(errCode, E_ERROR);
1940 }
1941
1942 /**
1943 * @tc.name: Abnormal_CacheResultSet003
1944 * @tc.desc: Abnormal testcase of CacheResultSet, if CacheResultSet is Empty
1945 * @tc.type: FUNC
1946 */
1947 HWTEST_F(RdbStepResultSetTest, Abnormal_CacheResultSet003, TestSize.Level1)
1948 {
1949 std::vector<OHOS::NativeRdb::ValuesBucket> valueBuckets;
1950 // if valuebucket.size = 0
1951 std::shared_ptr<OHOS::NativeRdb::CacheResultSet> resultSet =
1952 std::make_shared<CacheResultSet>(std::move(valueBuckets));
1953
1954 int errCode = 0;
1955 int columnIndex = 0;
1956 // if columnName is not exist
1957 errCode = resultSet->GetColumnIndex("empty", columnIndex);
1958 EXPECT_NE(errCode, E_OK);
1959 // if columnIndex < 0
1960 std::string columnName;
1961 errCode = resultSet->GetColumnName(-1, columnName);
1962 EXPECT_NE(errCode, E_OK);
1963 // if columnIndex > colNames_.size
1964 errCode = resultSet->GetColumnName(5, columnName);
1965 EXPECT_NE(errCode, E_OK);
1966
1967 // if columnIndex < 0
1968 ColumnType columnType;
1969 errCode = resultSet->GetColumnType(-1, columnType);
1970 EXPECT_NE(errCode, E_OK);
1971 // if columnIndex > colNames_.size
1972 errCode = resultSet->GetColumnType(5, columnType);
1973 EXPECT_NE(errCode, E_OK);
1974
1975 // if columnIndex < 0
1976 int id;
1977 errCode = resultSet->GetInt(-1, id);
1978 EXPECT_NE(errCode, E_OK);
1979 // if columnIndex > colNames_.size
1980 errCode = resultSet->GetInt(5, id);
1981 EXPECT_NE(errCode, E_OK);
1982
1983 // if columnIndex < 0
1984 std::string name;
1985 errCode = resultSet->GetString(-1, name);
1986 EXPECT_NE(errCode, E_OK);
1987 // if columnIndex > colNames_.size
1988 errCode = resultSet->GetString(5, name);
1989 EXPECT_NE(errCode, E_OK);
1990
1991 // if columnIndex < 0
1992 int64_t age;
1993 errCode = resultSet->GetLong(-1, age);
1994 EXPECT_NE(errCode, E_OK);
1995 // if columnIndex > colNames_.size
1996 errCode = resultSet->GetLong(5, age);
1997 EXPECT_NE(errCode, E_OK);
1998
1999 // if columnIndex < 0
2000 double value;
2001 errCode = resultSet->GetDouble(-1, value);
2002 EXPECT_NE(errCode, E_OK);
2003 // if columnIndex > colNames_.size
2004 errCode = resultSet->GetDouble(5, value);
2005 EXPECT_NE(errCode, E_OK);
2006 }
2007
2008 /**
2009 * @tc.name: Abnormal_CacheResultSet004
2010 * @tc.desc: Abnormal testcase of CacheResultSet, if CacheResultSet is Empty
2011 * @tc.type: FUNC
2012 */
2013 HWTEST_F(RdbStepResultSetTest, Abnormal_CacheResultSet004, TestSize.Level1)
2014 {
2015 std::vector<OHOS::NativeRdb::ValuesBucket> valueBuckets;
2016 std::shared_ptr<OHOS::NativeRdb::CacheResultSet> resultSet =
2017 std::make_shared<CacheResultSet>(std::move(valueBuckets));
2018 int errCode = 0;
2019 // if columnIndex < 0
2020 bool isNull;
2021 errCode = resultSet->IsColumnNull(-1, isNull);
2022 EXPECT_NE(errCode, E_OK);
2023 // if columnIndex > colNames_.size
2024 errCode = resultSet->IsColumnNull(5, isNull);
2025 EXPECT_NE(errCode, E_OK);
2026
2027 // if columnIndex < 0
2028 ValueObject::Asset asset;
2029 errCode = resultSet->GetAsset(-1, asset);
2030 EXPECT_NE(errCode, E_OK);
2031 // if columnIndex > colNames_.size
2032 errCode = resultSet->GetAsset(5, asset);
2033 EXPECT_NE(errCode, E_OK);
2034
2035 // if columnIndex < 0
2036 ValueObject::Assets assets;
2037 errCode = resultSet->GetAssets(-1, assets);
2038 EXPECT_NE(errCode, E_OK);
2039 // if columnIndex > colNames_.size
2040 errCode = resultSet->GetAssets(5, assets);
2041 EXPECT_NE(errCode, E_OK);
2042
2043 // if columnIndex < 0
2044 ValueObject valueobject;
2045 errCode = resultSet->Get(-1, valueobject);
2046 EXPECT_NE(errCode, E_OK);
2047 // if columnIndex > colNames_.size
2048 errCode = resultSet->Get(5, valueobject);
2049 EXPECT_NE(errCode, E_OK);
2050 }
2051 } // namespace NativeRdb
2052 } // namespace OHOS
2053