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