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