1 /*
2 * Copyright (c) 2023 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 "cache_result_set.h"
17
18 #include <gtest/gtest.h>
19
20 #include <map>
21 #include <string>
22
23 #include "common.h"
24 #include "rdb_errno.h"
25 #include "value_object.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::NativeRdb;
29 using Asset = ValueObject::Asset;
30 using Assets = ValueObject::Assets;
31 class CacheResultSetTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void CacheResultSetTest::SetUpTestCase(void)
40 {
41 }
42
TearDownTestCase(void)43 void CacheResultSetTest::TearDownTestCase(void)
44 {
45 }
46
SetUp()47 void CacheResultSetTest::SetUp()
48 {
49 }
50
TearDown()51 void CacheResultSetTest::TearDown()
52 {
53 }
54
55 /* *
56 * @tc.name: GetRowCountTest_001
57 * @tc.desc: Normal testCase for CacheResultSet, get the number of rows from the list
58 * @tc.type: FUNC
59 */
60 HWTEST_F(CacheResultSetTest, GetRowCountTest_001, TestSize.Level2)
61 {
62 std::vector<ValuesBucket> valuesBuckets;
63 ValuesBucket valuesBucket;
64 valuesBucket.Put("id", 1);
65 valuesBucket.Put("data", "test");
66 valuesBucket.Put("field", "test");
67 valuesBuckets.push_back(std::move(valuesBucket));
68 CacheResultSet cacheResultSet(std::move(valuesBuckets));
69
70 int count = 0;
71 int ret = cacheResultSet.GetRowCount(count);
72 EXPECT_EQ(E_OK, ret);
73 EXPECT_EQ(count, 1);
74 }
75
76 /* *
77 * @tc.name: GetAllColumnNamesTest_001
78 * @tc.desc: Normal testCase for CacheResultSet, get the all column names from the list
79 * @tc.type: FUNC
80 */
81 HWTEST_F(CacheResultSetTest, GetAllColumnNamesTest_001, TestSize.Level2)
82 {
83 std::vector<ValuesBucket> valuesBuckets;
84 ValuesBucket valuesBucket;
85 std::set<std::string> columnNames = { "id", "data", "field" };
86 for (auto &column : columnNames) {
87 valuesBucket.Put(column, "test");
88 }
89 valuesBuckets.push_back(std::move(valuesBucket));
90 CacheResultSet cacheResultSet(std::move(valuesBuckets));
91
92 std::vector<std::string> columnNamesTmp = {};
93 int ret = cacheResultSet.GetAllColumnNames(columnNamesTmp);
94 EXPECT_EQ(E_OK, ret);
95 EXPECT_EQ(std::set<std::string>(columnNamesTmp.begin(), columnNamesTmp.end()), columnNames);
96 }
97
98 /* *
99 * @tc.name: GetBlobTest_001
100 * @tc.desc: Normal testCase for CacheResultSet, get blob of type from the list
101 * @tc.type: FUNC
102 */
103 HWTEST_F(CacheResultSetTest, GetBlobTest_001, TestSize.Level2)
104 {
105 std::vector<ValuesBucket> valuesBuckets;
106 ValuesBucket valuesBucket;
107 valuesBucket.Put("id", 1);
108 std::vector<uint8_t> blob = { 't', 'e', 's', 't' };
109 valuesBucket.Put("data", blob);
110 valuesBucket.Put("field", "test");
111 valuesBuckets.push_back(std::move(valuesBucket));
112 CacheResultSet cacheResultSet(std::move(valuesBuckets));
113
114 int columnIndex = 0;
115 EXPECT_EQ(E_OK, cacheResultSet.GetColumnIndex("data", columnIndex));
116 std::vector<uint8_t> blobOut = {};
117 EXPECT_EQ(E_OK, cacheResultSet.GetBlob(columnIndex, blobOut));
118 EXPECT_EQ(blob, blobOut);
119
120 EXPECT_EQ(E_OK, cacheResultSet.GetColumnIndex("id", columnIndex));
121 EXPECT_NE(E_OK, cacheResultSet.GetBlob(columnIndex, blobOut));
122 }
123
124 /* *
125 * @tc.name: GetStringTest_001
126 * @tc.desc: Normal testCase for CacheResultSet, get string of type from the list
127 * @tc.type: FUNC
128 */
129 HWTEST_F(CacheResultSetTest, GetStringTest_001, TestSize.Level2)
130 {
131 std::vector<ValuesBucket> valuesBuckets;
132 ValuesBucket valuesBucket;
133 std::set<std::string> columnNames = { "id", "data", "field" };
134 for (auto &column : columnNames) {
135 valuesBucket.Put(column, "test");
136 }
137 valuesBuckets.push_back(std::move(valuesBucket));
138 CacheResultSet cacheResultSet(std::move(valuesBuckets));
139
140 int columnIndex = 0;
141 std::string value;
142 int ret = cacheResultSet.GetString(columnIndex, value);
143 EXPECT_EQ(E_OK, ret);
144 EXPECT_EQ("test", value);
145 }
146
147 /* *
148 * @tc.name: GetIntTest_001
149 * @tc.desc: Normal testCase for CacheResultSet, get int of type from the list
150 * @tc.type: FUNC
151 */
152 HWTEST_F(CacheResultSetTest, GetIntTest_001, TestSize.Level2)
153 {
154 std::vector<ValuesBucket> valuesBuckets;
155 ValuesBucket valuesBucket;
156 std::set<std::string> columnNames = { "id", "data", "field" };
157 for (auto &column : columnNames) {
158 valuesBucket.Put(column, 111);
159 }
160 valuesBuckets.push_back(std::move(valuesBucket));
161 CacheResultSet cacheResultSet(std::move(valuesBuckets));
162
163 int columnIndex = 1;
164 int value;
165 int ret = cacheResultSet.GetInt(columnIndex, value);
166 EXPECT_EQ(E_OK, ret);
167 EXPECT_EQ(111, value);
168 }
169
170 /* *
171 * @tc.name: GetLongTest_001
172 * @tc.desc: Normal testCase for CacheResultSet, get long of type from the list
173 * @tc.type: FUNC
174 */
175 HWTEST_F(CacheResultSetTest, GetLongTest_001, TestSize.Level2)
176 {
177 std::vector<ValuesBucket> valuesBuckets;
178 ValuesBucket valuesBucket;
179 std::set<std::string> columnNames = { "id", "data", "field" };
180 for (auto &column : columnNames) {
181 valuesBucket.Put(column, 11111111);
182 }
183 valuesBuckets.push_back(std::move(valuesBucket));
184 CacheResultSet cacheResultSet(std::move(valuesBuckets));
185
186 int columnIndex = 1;
187 int64_t value;
188 int ret = cacheResultSet.GetLong(columnIndex, value);
189 EXPECT_EQ(E_OK, ret);
190 EXPECT_EQ(11111111, value);
191 }
192
193 /* *
194 * @tc.name: GetDoubleTest_001
195 * @tc.desc: Normal testCase for CacheResultSet, get double of type from the list
196 * @tc.type: FUNC
197 */
198 HWTEST_F(CacheResultSetTest, GetDoubleTest_001, TestSize.Level2)
199 {
200 std::vector<ValuesBucket> valuesBuckets;
201 ValuesBucket valuesBucket;
202 std::set<std::string> columnNames = { "id", "data", "field" };
203 for (auto &column : columnNames) {
204 valuesBucket.Put(column, 1111.1111);
205 }
206 valuesBuckets.push_back(std::move(valuesBucket));
207 CacheResultSet cacheResultSet(std::move(valuesBuckets));
208
209 int columnIndex = 1;
210 double value;
211 int ret = cacheResultSet.GetDouble(columnIndex, value);
212 EXPECT_EQ(E_OK, ret);
213 EXPECT_EQ(1111.1111, value);
214 }
215
216 /* *
217 * @tc.name: GetAssetTest_001
218 * @tc.desc: Normal testCase for CacheResultSet, get asset of type from the list
219 * @tc.type: FUNC
220 */
221 HWTEST_F(CacheResultSetTest, GetAssetTest_001, TestSize.Level2)
222 {
223 std::vector<ValuesBucket> valuesBuckets;
224 ValuesBucket valuesBucket;
225 valuesBucket.Put("id", 1);
226 ValueObject::Asset value = {};
227 valuesBucket.Put("data", value);
228 valuesBucket.Put("field", "test");
229 valuesBuckets.push_back(std::move(valuesBucket));
230 CacheResultSet cacheResultSet(std::move(valuesBuckets));
231
232 int32_t col = 0;
233 EXPECT_EQ(E_OK, cacheResultSet.GetColumnIndex("data", col));
234 ValueObject::Asset valueOut = {};
235 EXPECT_EQ(E_OK, cacheResultSet.GetAsset(col, valueOut));
236
237 EXPECT_EQ(E_OK, cacheResultSet.GetColumnIndex("id", col));
238 EXPECT_NE(E_OK, cacheResultSet.GetAsset(col, valueOut));
239 }
240
241 /* *
242 * @tc.name: GetAssetsTest_001
243 * @tc.desc: Normal testCase for CacheResultSet, get assets of type from the list
244 * @tc.type: FUNC
245 */
246 HWTEST_F(CacheResultSetTest, GetAssetsTest_001, TestSize.Level2)
247 {
248 std::vector<ValuesBucket> valuesBuckets;
249 ValuesBucket valuesBucket;
250 valuesBucket.Put("id", 1);
251 ValueObject::Assets value = {};
252 valuesBucket.Put("data", value);
253 valuesBucket.Put("field", "test");
254 valuesBuckets.push_back(std::move(valuesBucket));
255 CacheResultSet cacheResultSet(std::move(valuesBuckets));
256
257 int32_t col = 0;
258 EXPECT_EQ(E_OK, cacheResultSet.GetColumnIndex("data", col));
259 ValueObject::Assets valueOut = {};
260 EXPECT_EQ(E_OK, cacheResultSet.GetAssets(col, valueOut));
261
262 EXPECT_EQ(E_OK, cacheResultSet.GetColumnIndex("id", col));
263 EXPECT_NE(E_OK, cacheResultSet.GetAssets(col, valueOut));
264 }
265
266 /* *
267 * @tc.name: GetTest_001
268 * @tc.desc: Normal testCase for CacheResultSet, get list
269 * @tc.type: FUNC
270 */
271 HWTEST_F(CacheResultSetTest, GetTest_001, TestSize.Level2)
272 {
273 std::vector<ValuesBucket> valuesBuckets;
274 ValuesBucket valuesBucket;
275 std::set<std::string> columnNames = { "id", "data", "field" };
276 for (auto &column : columnNames) {
277 valuesBucket.Put(column, 10);
278 }
279 valuesBuckets.push_back(std::move(valuesBucket));
280 CacheResultSet cacheResultSet(std::move(valuesBuckets));
281
282 ValueObject value;
283 int res;
284 EXPECT_EQ(E_OK, cacheResultSet.Get(0, value));
285 EXPECT_EQ(E_OK, value.GetInt(res));
286 EXPECT_EQ(res, 10);
287 }
288
289 /* *
290 * @tc.name: IsColumnNullTest_001
291 * @tc.desc: Normal testCase for CacheResultSet, check if the column is empty
292 * @tc.type: FUNC
293 */
294 HWTEST_F(CacheResultSetTest, IsColumnNullTest_001, TestSize.Level2)
295 {
296 std::vector<ValuesBucket> valuesBuckets;
297 ValuesBucket valuesBucket;
298 valuesBucket.Put("id", 1);
299 valuesBucket.Put("data", "test");
300 valuesBucket.Put("field", "test");
301 valuesBucket.PutNull("null");
302 valuesBuckets.push_back(std::move(valuesBucket));
303 CacheResultSet cacheResultSet(std::move(valuesBuckets));
304
305 int columnIndex = 1;
306 bool isNull = true;
307 int ret = cacheResultSet.IsColumnNull(columnIndex, isNull);
308 EXPECT_EQ(E_OK, ret);
309 EXPECT_EQ(false, isNull);
310
311 columnIndex = 3;
312 int rets = cacheResultSet.IsColumnNull(columnIndex, isNull);
313 EXPECT_EQ(E_OK, rets);
314 EXPECT_EQ(true, isNull);
315 }
316
317 /* *
318 * @tc.name: GetRowTest_001
319 * @tc.desc: Normal testCase for CacheResultSet, get row from the list
320 * @tc.type: FUNC
321 */
322 HWTEST_F(CacheResultSetTest, GetRowTest_001, TestSize.Level2)
323 {
324 std::vector<ValuesBucket> valuesBuckets;
325 ValuesBucket valuesBucket;
326 std::set<std::string> columnNames = { "id", "data", "field" };
327 for (auto &column : columnNames) {
328 valuesBucket.Put(column, "1");
329 }
330 valuesBuckets.push_back(std::move(valuesBucket));
331 CacheResultSet cacheResultSet(std::move(valuesBuckets));
332
333 RowEntity rowEntity;
334 EXPECT_EQ(E_OK, cacheResultSet.GetRow(rowEntity));
335 for (auto &columnName : columnNames) {
336 auto value = rowEntity.Get(columnName);
337 string res;
338 EXPECT_EQ(E_OK, value.GetString(res));
339 EXPECT_EQ("1", res);
340 }
341 }
342
343 /* *
344 * @tc.name: GoToRowTest_001
345 * @tc.desc: Normal testCase for CacheResultSet, go to row in the list
346 * @tc.type: FUNC
347 */
348 HWTEST_F(CacheResultSetTest, GoToRowTest_001, TestSize.Level2)
349 {
350 std::vector<ValuesBucket> valuesBuckets;
351 ValuesBucket valuesBucket;
352 std::set<std::string> columnNames = { "id", "data", "field" };
353 for (auto &column : columnNames) {
354 valuesBucket.Put(column, "1");
355 }
356 valuesBuckets.push_back(std::move(valuesBucket));
357 CacheResultSet cacheResultSet(std::move(valuesBuckets));
358
359 int position = 0;
360 int ret = cacheResultSet.GoToRow(position);
361 EXPECT_EQ(E_OK, ret);
362 EXPECT_EQ(0, position);
363 }
364
365 /* *
366 * @tc.name: GetColumnTypeTest_001
367 * @tc.desc: Normal testCase for CacheResultSet, get column type from the list
368 * @tc.type: FUNC
369 */
370 HWTEST_F(CacheResultSetTest, GetColumnTypeTest_001, TestSize.Level2)
371 {
372 std::vector<ValuesBucket> valuesBuckets;
373 ValuesBucket valuesBucket;
374 std::set<std::string> columnNames = { "id", "data", "field" };
375 for (auto &column : columnNames) {
376 valuesBucket.Put(column, "1");
377 }
378 valuesBuckets.push_back(std::move(valuesBucket));
379 CacheResultSet cacheResultSet(std::move(valuesBuckets));
380
381 int columnIndex = 1;
382 ColumnType columnType;
383 int ret = cacheResultSet.GetColumnType(columnIndex, columnType);
384 EXPECT_EQ(E_OK, ret);
385 EXPECT_EQ(ColumnType::TYPE_STRING, columnType);
386 }
387
388 /* *
389 * @tc.name: GetRowIndexTest_001
390 * @tc.desc: Normal testCase for CacheResultSet, get row index from the list
391 * @tc.type: FUNC
392 */
393 HWTEST_F(CacheResultSetTest, GetRowIndexTest_001, TestSize.Level2)
394 {
395 std::vector<ValuesBucket> valuesBuckets;
396 ValuesBucket valuesBucket;
397 std::set<std::string> columnNames = { "id", "data", "field" };
398 for (auto &column : columnNames) {
399 valuesBucket.Put(column, "1");
400 }
401 valuesBuckets.push_back(std::move(valuesBucket));
402 CacheResultSet cacheResultSet(std::move(valuesBuckets));
403
404 int columnIndex = 1;
405 int ret = cacheResultSet.GetRowIndex(columnIndex);
406 EXPECT_EQ(E_OK, ret);
407 EXPECT_EQ(0, columnIndex);
408 }
409
410 /* *
411 * @tc.name: GoToTest_001
412 * @tc.desc: Normal testCase for CacheResultSet, go to a specific line
413 * @tc.type: FUNC
414 */
415 HWTEST_F(CacheResultSetTest, GoToTest_001, TestSize.Level2)
416 {
417 std::vector<ValuesBucket> valuesBuckets;
418 for (int i = 0; i < 5; i++) {
419 ValuesBucket valuesBucket;
420 std::set<std::string> columnNames = { "id", "data", "field" };
421 for (auto &column : columnNames) {
422 valuesBucket.Put(column, "test" + std::to_string(i));
423 }
424 valuesBuckets.push_back(std::move(valuesBucket));
425 }
426 CacheResultSet cacheResultSet(std::move(valuesBuckets));
427
428 // now position is 0
429 int offset = 1;
430 // go to position 1
431 EXPECT_EQ(E_OK, cacheResultSet.GoTo(offset));
432 std::string value;
433 EXPECT_EQ(E_OK, cacheResultSet.GetString(0, value));
434 EXPECT_EQ(value, "test1");
435
436 EXPECT_EQ(E_OK, cacheResultSet.GoToRow(3));
437 EXPECT_EQ(E_OK, cacheResultSet.GetString(0, value));
438 EXPECT_EQ(value, "test3");
439
440 // exceed maxRow
441 EXPECT_NE(E_OK, cacheResultSet.GoTo(2));
442 }
443
444 /* *
445 * @tc.name: GoToFirstRowTest_001
446 * @tc.desc: Normal testCase for CacheResultSet, get the first row of the list
447 * @tc.type: FUNC
448 */
449 HWTEST_F(CacheResultSetTest, GoToFirstRowTest_001, TestSize.Level2)
450 {
451 std::vector<ValuesBucket> valuesBuckets;
452 ValuesBucket valuesBucket;
453 std::set<std::string> columnNames = { "id", "data", "field" };
454 for (auto &column : columnNames) {
455 valuesBucket.Put(column, "test");
456 }
457 valuesBuckets.push_back(std::move(valuesBucket));
458 CacheResultSet cacheResultSet(std::move(valuesBuckets));
459
460 EXPECT_EQ(E_OK, cacheResultSet.GoToFirstRow());
461 int position = -1;
462 EXPECT_EQ(E_OK, cacheResultSet.GetRowIndex(position));
463 EXPECT_EQ(position, 0);
464 }
465
466 /* *
467 * @tc.name: GoToLastRowTest_001
468 * @tc.desc: Normal testCase for CacheResultSet, get the last row of the list
469 * @tc.type: FUNC
470 */
471 HWTEST_F(CacheResultSetTest, GoToLastRowTest_001, TestSize.Level2)
472 {
473 std::vector<ValuesBucket> valuesBuckets;
474 ValuesBucket valuesBucket;
475 std::set<std::string> columnNames = { "id", "data", "field" };
476 for (auto &column : columnNames) {
477 valuesBucket.Put(column, "test");
478 }
479 valuesBuckets.push_back(std::move(valuesBucket));
480 CacheResultSet cacheResultSet(std::move(valuesBuckets));
481
482 EXPECT_EQ(E_OK, cacheResultSet.GoToLastRow());
483 int position = -1;
484 EXPECT_EQ(E_OK, cacheResultSet.GetRowIndex(position));
485 EXPECT_EQ(position, 0);
486 }
487
488 /* *
489 * @tc.name: GoToNextRowTest_001
490 * @tc.desc: Normal testCase for CacheResultSet, get the next row of the list
491 * @tc.type: FUNC
492 */
493 HWTEST_F(CacheResultSetTest, GoToNextRowTest_001, TestSize.Level2)
494 {
495 std::vector<ValuesBucket> valuesBuckets;
496 for (int i = 0; i < 5; i++) {
497 ValuesBucket valuesBucket;
498 std::set<std::string> columnNames = { "id", "data", "field" };
499 for (auto &column : columnNames) {
500 valuesBucket.Put(column, "test" + std::to_string(i));
501 }
502 valuesBuckets.push_back(std::move(valuesBucket));
503 }
504 CacheResultSet cacheResultSet(std::move(valuesBuckets));
505
506 EXPECT_EQ(E_OK, cacheResultSet.GoToNextRow());
507 int position = -1;
508 EXPECT_EQ(E_OK, cacheResultSet.GetRowIndex(position));
509 EXPECT_EQ(position, 1);
510 }
511
512 /* *
513 * @tc.name: GoToPreviousRowTest_001
514 * @tc.desc: Normal testCase for CacheResultSet, get the previous row of the list
515 * @tc.type: FUNC
516 */
517 HWTEST_F(CacheResultSetTest, GoToPreviousRowTest_001, TestSize.Level2)
518 {
519 std::vector<ValuesBucket> valuesBuckets;
520 ValuesBucket valuesBucket;
521 valuesBucket.Put("id", 1);
522 valuesBucket.Put("data", "test");
523 valuesBucket.Put("field", "test");
524 valuesBuckets.push_back(std::move(valuesBucket));
525 CacheResultSet cacheResultSet(std::move(valuesBuckets));
526
527 int offset = 1;
528 int position = 0;
529 cacheResultSet.GoToRow(position);
530 cacheResultSet.GoTo(offset);
531 int ret = cacheResultSet.GoToPreviousRow();
532 EXPECT_EQ(E_OK, ret);
533 }
534
535 /* *
536 * @tc.name: IsAtFirstRowTest_001
537 * @tc.desc: Normal testCase for CacheResultSet, is it on the first line
538 * @tc.type: FUNC
539 */
540 HWTEST_F(CacheResultSetTest, IsAtFirstRowTest_001, TestSize.Level2)
541 {
542 std::vector<ValuesBucket> valuesBuckets;
543 ValuesBucket valuesBucket;
544 valuesBucket.Put("id", 1);
545 valuesBucket.Put("data", "test");
546 valuesBucket.Put("field", "test");
547 valuesBuckets.push_back(std::move(valuesBucket));
548 CacheResultSet cacheResultSet(std::move(valuesBuckets));
549
550 bool result = false;
551 EXPECT_EQ(E_OK, cacheResultSet.IsAtFirstRow(result));
552 EXPECT_TRUE(result);
553 EXPECT_NE(E_OK, cacheResultSet.GoToNextRow());
554 EXPECT_EQ(E_OK, cacheResultSet.IsAtLastRow(result));
555 EXPECT_FALSE(result);
556 }
557
558 /* *
559 * @tc.name: IsAtLastRowTest_001
560 * @tc.desc: Normal testCase for CacheResultSet, is it on the last line
561 * @tc.type: FUNC
562 */
563 HWTEST_F(CacheResultSetTest, IsAtLastRowTest_001, TestSize.Level2)
564 {
565 std::vector<ValuesBucket> valuesBuckets;
566 ValuesBucket valuesBucket;
567 valuesBucket.Put("id", 1);
568 valuesBucket.Put("data", "test");
569 valuesBucket.Put("field", "test");
570 valuesBuckets.push_back(std::move(valuesBucket));
571 CacheResultSet cacheResultSet(std::move(valuesBuckets));
572
573 bool result = false;
574 EXPECT_EQ(E_OK, cacheResultSet.IsAtLastRow(result));
575 EXPECT_TRUE(result);
576 EXPECT_NE(E_OK, cacheResultSet.GoToNextRow());
577 EXPECT_EQ(E_OK, cacheResultSet.IsAtLastRow(result));
578 EXPECT_FALSE(result);
579 }
580
581 /* *
582 * @tc.name: IsStartedTest_001
583 * @tc.desc: Normal testCase for CacheResultSet, is it at the starting
584 * @tc.type: FUNC
585 */
586 HWTEST_F(CacheResultSetTest, IsStartedTest_001, TestSize.Level2)
587 {
588 std::vector<ValuesBucket> valuesBuckets;
589 ValuesBucket valuesBucket;
590 valuesBucket.Put("id", 1);
591 valuesBucket.Put("data", "test");
592 valuesBucket.Put("field", "test");
593 valuesBuckets.push_back(std::move(valuesBucket));
594 CacheResultSet cacheResultSet(std::move(valuesBuckets));
595
596 bool result = true;
597 int ret = cacheResultSet.IsStarted(result);
598 EXPECT_EQ(E_OK, ret);
599 EXPECT_EQ(false, result);
600 }
601
602 /* *
603 * @tc.name: IsEndedTest_001
604 * @tc.desc: Normal testCase for CacheResultSet, is it at the end
605 * @tc.type: FUNC
606 */
607 HWTEST_F(CacheResultSetTest, IsEndedTest_001, TestSize.Level2)
608 {
609 std::vector<ValuesBucket> valuesBuckets;
610 ValuesBucket valuesBucket;
611 valuesBucket.Put("id", 1);
612 valuesBucket.Put("data", "test");
613 valuesBucket.Put("field", "test");
614 valuesBuckets.push_back(std::move(valuesBucket));
615 CacheResultSet cacheResultSet(std::move(valuesBuckets));
616
617 bool result = true;
618 int ret = cacheResultSet.IsEnded(result);
619 EXPECT_EQ(E_OK, ret);
620 EXPECT_EQ(false, result);
621 }
622
623 /* *
624 * @tc.name: GetColumnCountTest_001
625 * @tc.desc: Normal testCase for CacheResultSet, get the number of columns in the list
626 * @tc.type: FUNC
627 */
628 HWTEST_F(CacheResultSetTest, GetColumnCountTest_001, TestSize.Level2)
629 {
630 std::vector<ValuesBucket> valuesBuckets;
631 ValuesBucket valuesBucket;
632 valuesBucket.Put("id", 1);
633 valuesBucket.Put("data", "test");
634 valuesBucket.Put("field", "test");
635 valuesBuckets.push_back(std::move(valuesBucket));
636 CacheResultSet cacheResultSet(std::move(valuesBuckets));
637
638 int count = 0;
639 int ret = cacheResultSet.GetColumnCount(count);
640 EXPECT_EQ(E_OK, ret);
641 EXPECT_EQ(3, count);
642 }
643
644 /* *
645 * @tc.name: GetColumnIndexTest_001
646 * @tc.desc: Normal testCase for CacheResultSet, get the number of columnsIndex in the list
647 * @tc.type: FUNC
648 */
649 HWTEST_F(CacheResultSetTest, GetColumnIndexTest_001, TestSize.Level2)
650 {
651 std::vector<ValuesBucket> valuesBuckets;
652 ValuesBucket valuesBucket;
653 valuesBucket.Put("id", 1);
654 valuesBucket.Put("data", "test");
655 valuesBucket.Put("field", "test");
656 valuesBuckets.push_back(std::move(valuesBucket));
657 CacheResultSet cacheResultSet(std::move(valuesBuckets));
658
659 std::string columnName = "field";
660 int columnIndex;
661 int ret = cacheResultSet.GetColumnIndex(columnName, columnIndex);
662 EXPECT_EQ(E_OK, ret);
663 EXPECT_EQ(1, columnIndex);
664
665 columnName = "wang";
666 ret = cacheResultSet.GetColumnIndex(columnName, columnIndex);
667 EXPECT_NE(E_OK, ret);
668 }
669
670 /* *
671 * @tc.name: GetColumnNameTest_001
672 * @tc.desc: Normal testCase for CacheResultSet, get the number of columnsName in the list
673 * @tc.type: FUNC
674 */
675 HWTEST_F(CacheResultSetTest, GetColumnNameTest_001, TestSize.Level2)
676 {
677 std::vector<ValuesBucket> valuesBuckets;
678 ValuesBucket valuesBucket;
679 std::set<std::string> columnNames = { "id", "data", "field" };
680 for (auto &column : columnNames) {
681 valuesBucket.Put(column, "test");
682 }
683 valuesBuckets.push_back(std::move(valuesBucket));
684 CacheResultSet cacheResultSet(std::move(valuesBuckets));
685
686 std::string columnName;
687 std::vector<std::string> columnNamesTmp = {};
688 for (int i = 0; i < 3; i++) {
689 EXPECT_EQ(E_OK, cacheResultSet.GetColumnName(i, columnName));
690 columnNamesTmp.push_back(columnName);
691 }
692 EXPECT_EQ(std::set<std::string>(columnNamesTmp.begin(), columnNamesTmp.end()), columnNames);
693 }
694
695 /* *
696 * @tc.name: IsClosedTest_001
697 * @tc.desc: Normal testCase for CacheResultSet, is the list closed
698 * @tc.type: FUNC
699 */
700 HWTEST_F(CacheResultSetTest, IsClosedTest_001, TestSize.Level2)
701 {
702 std::vector<ValuesBucket> valuesBuckets;
703 ValuesBucket valuesBucket;
704 valuesBucket.Put("id", 1);
705 valuesBucket.Put("data", "test");
706 valuesBucket.Put("field", "test");
707 valuesBuckets.push_back(std::move(valuesBucket));
708 CacheResultSet cacheResultSet(std::move(valuesBuckets));
709
710 EXPECT_EQ(false, cacheResultSet.IsClosed());
711 }
712
713 /* *
714 * @tc.name: CloseTest_001
715 * @tc.desc: Normal testCase for CacheResultSet, close list
716 * @tc.type: FUNC
717 */
718 HWTEST_F(CacheResultSetTest, CloseTest_001, TestSize.Level2)
719 {
720 std::vector<ValuesBucket> valuesBuckets;
721 ValuesBucket valuesBucket;
722 valuesBucket.Put("id", 1);
723 valuesBucket.Put("data", "test");
724 valuesBucket.Put("field", "test");
725 valuesBuckets.push_back(std::move(valuesBucket));
726 CacheResultSet cacheResultSet(std::move(valuesBuckets));
727
728 int ret = cacheResultSet.Close();
729 EXPECT_EQ(E_NOT_SUPPORT, ret);
730 }
731
732 /* *
733 * @tc.name: GetSizeTest_001
734 * @tc.desc: Normal testCase for CacheResultSet, get size
735 * @tc.type: FUNC
736 */
737 HWTEST_F(CacheResultSetTest, GetSizeTest_001, TestSize.Level2)
738 {
739 std::vector<ValuesBucket> valuesBuckets;
740 ValuesBucket valuesBucket;
741 valuesBucket.Put("id", 1);
742 valuesBucket.Put("data", "test");
743 valuesBucket.Put("field", "test");
744 valuesBuckets.push_back(std::move(valuesBucket));
745 CacheResultSet cacheResultSet(std::move(valuesBuckets));
746
747 int columnIndex = 0;
748 size_t size;
749 int ret = cacheResultSet.GetSize(columnIndex, size);
750 EXPECT_EQ(E_NOT_SUPPORT, ret);
751 }