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