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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "clouddisk_rdb_utils.h"
20 #include "dfs_error.h"
21 #include "result_set_mock.h"
22 #include "file_column.h"
23
24 namespace OHOS {
25 namespace FileManagement::CloudDisk {
26 namespace Test {
27 using namespace testing::ext;
28 using namespace std;
29
30 class CloudDiskRdbUtilsTest : 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 CloudDiskRdbUtilsTest::SetUpTestCase(void)
39 {
40 std::cout << "SetUpTestCase" << std::endl;
41 }
42
TearDownTestCase(void)43 void CloudDiskRdbUtilsTest::TearDownTestCase(void)
44 {
45 std::cout << "TearDownTestCase" << std::endl;
46 }
47
SetUp(void)48 void CloudDiskRdbUtilsTest::SetUp(void)
49 {
50 std::cout << "SetUp" << std::endl;
51 }
52
TearDown(void)53 void CloudDiskRdbUtilsTest::TearDown(void)
54 {
55 std::cout << "TearDown" << std::endl;
56 }
57
58 /**
59 * @tc.name: GetIntTest001
60 * @tc.desc: Verify the GetInt function.
61 * @tc.type: FUNC
62 * @tc.require: I6H5MH
63 */
64 HWTEST_F(CloudDiskRdbUtilsTest, GetIntTest001, TestSize.Level1)
65 {
66 GTEST_LOG_(INFO) << "GetInt Start";
67 const string key = FileColumn::IS_DIRECTORY;
68 int32_t value;
69 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
70 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
71 EXPECT_CALL(*resultSet, GetInt(_, _)).WillOnce(Return(E_OK));
72 int32_t ret = CloudDiskRdbUtils::GetInt(key, value, resultSet);
73 EXPECT_EQ(ret, E_OK);
74 GTEST_LOG_(INFO) << "GetInt End";
75 }
76
77 /**
78 * @tc.name: GetIntTest002
79 * @tc.desc: Verify the GetInt function.
80 * @tc.type: FUNC
81 * @tc.require: I6H5MH
82 */
83 HWTEST_F(CloudDiskRdbUtilsTest, GetIntTest002, TestSize.Level1)
84 {
85 GTEST_LOG_(INFO) << "GetInt Start";
86 try {
87 const string key = "";
88 int32_t value;
89 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
90 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
91 EXPECT_CALL(*resultSet, GetInt(_, _)).WillOnce(Return(E_OK));
92 int32_t ret = CloudDiskRdbUtils::GetInt(key, value, std::move(resultSet));
93 EXPECT_EQ(ret, E_OK);
94 } catch(...) {
95 EXPECT_TRUE(false);
96 GTEST_LOG_(INFO) << " GetInt ERROR";
97 }
98 GTEST_LOG_(INFO) << "GetInt End";
99 }
100
101 /**
102 * @tc.name: GetIntTest003
103 * @tc.desc: Verify the GetInt function.
104 * @tc.type: FUNC
105 * @tc.require: I6H5MH
106 */
107 HWTEST_F(CloudDiskRdbUtilsTest, GetIntTest003, TestSize.Level1)
108 {
109 GTEST_LOG_(INFO) << "GetInt Start";
110 try {
111 const string key = FileColumn::IS_DIRECTORY;
112 int32_t value;
113 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
114 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_RDB));
115 int32_t ret = CloudDiskRdbUtils::GetInt(key, value, std::move(resultSet));
116 EXPECT_EQ(ret, E_RDB);
117 } catch(...) {
118 EXPECT_TRUE(false);
119 GTEST_LOG_(INFO) << " GetInt ERROR";
120 }
121 GTEST_LOG_(INFO) << "GetInt End";
122 }
123
124 /**
125 * @tc.name: GetIntTest004
126 * @tc.desc: Verify the GetInt function.
127 * @tc.type: FUNC
128 * @tc.require: I6H5MH
129 */
130 HWTEST_F(CloudDiskRdbUtilsTest, GetIntTest004, TestSize.Level1)
131 {
132 GTEST_LOG_(INFO) << "GetInt Start";
133 try {
134 const string key = FileColumn::IS_DIRECTORY;
135 int32_t value;
136 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
137 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
138 EXPECT_CALL(*resultSet, GetInt(_, _)).WillOnce(Return(E_RDB));
139 int32_t ret = CloudDiskRdbUtils::GetInt(key, value, std::move(resultSet));
140 EXPECT_EQ(ret, E_RDB);
141 } catch(...) {
142 EXPECT_TRUE(false);
143 GTEST_LOG_(INFO) << " GetInt ERROR";
144 }
145 GTEST_LOG_(INFO) << "GetInt End";
146 }
147
148 /**
149 * @tc.name: GetIntTest005
150 * @tc.desc: Verify the GetInt function.
151 * @tc.type: FUNC
152 * @tc.require: I6H5MH
153 */
154 HWTEST_F(CloudDiskRdbUtilsTest, GetIntTest005, TestSize.Level1)
155 {
156 GTEST_LOG_(INFO) << "GetInt Start";
157 try {
158 const string key = FileColumn::IS_DIRECTORY;
159 int32_t value;
160 int32_t ret = CloudDiskRdbUtils::GetInt(key, value, nullptr);
161 EXPECT_EQ(ret, E_RDB);
162 } catch(...) {
163 EXPECT_TRUE(false);
164 GTEST_LOG_(INFO) << " GetInt ERROR";
165 }
166 GTEST_LOG_(INFO) << "GetInt End";
167 }
168
169 /**
170 * @tc.name: GetLongTest001
171 * @tc.desc: Verify the GetLong function.
172 * @tc.type: FUNC
173 * @tc.require: I6H5MH
174 */
175 HWTEST_F(CloudDiskRdbUtilsTest, GetLongTest001, TestSize.Level1)
176 {
177 GTEST_LOG_(INFO) << "GetLong Start";
178 const string key = FileColumn::FILE_SIZE;
179 int64_t value;
180 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
181 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
182 EXPECT_CALL(*resultSet, GetLong(_, _)).WillOnce(Return(E_OK));
183 int32_t ret = CloudDiskRdbUtils::GetLong(key, value, std::move(resultSet));
184 EXPECT_EQ(ret, E_OK);
185 GTEST_LOG_(INFO) << "GetLong End";
186 }
187
188 /**
189 * @tc.name: GetLongTest002
190 * @tc.desc: Verify the GetLong function.
191 * @tc.type: FUNC
192 * @tc.require: I6H5MH
193 */
194 HWTEST_F(CloudDiskRdbUtilsTest, GetLongTest002, TestSize.Level1)
195 {
196 GTEST_LOG_(INFO) << "GetLong Start";
197 try {
198 const string key = "";
199 int64_t value;
200 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
201 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
202 EXPECT_CALL(*resultSet, GetLong(_, _)).WillOnce(Return(E_OK));
203 int32_t ret = CloudDiskRdbUtils::GetLong(key, value, std::move(resultSet));
204 EXPECT_EQ(ret, E_OK);
205 } catch(...) {
206 EXPECT_TRUE(false);
207 GTEST_LOG_(INFO) << " GetLong ERROR";
208 }
209 GTEST_LOG_(INFO) << "GetLong End";
210 }
211
212 /**
213 * @tc.name: GetLongTest003
214 * @tc.desc: Verify the GetLong function.
215 * @tc.type: FUNC
216 * @tc.require: I6H5MH
217 */
218 HWTEST_F(CloudDiskRdbUtilsTest, GetLongTest003, TestSize.Level1)
219 {
220 GTEST_LOG_(INFO) << "GetLong Start";
221 try {
222 const string key = FileColumn::FILE_SIZE;
223 int64_t value;
224 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
225 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_RDB));
226 int32_t ret = CloudDiskRdbUtils::GetLong(key, value, resultSet);
227 EXPECT_EQ(ret, E_RDB);
228 } catch(...) {
229 EXPECT_TRUE(false);
230 GTEST_LOG_(INFO) << " GetLong ERROR";
231 }
232 GTEST_LOG_(INFO) << "GetLong End";
233 }
234
235 /**
236 * @tc.name: GetLongTest004
237 * @tc.desc: Verify the GetLong function.
238 * @tc.type: FUNC
239 * @tc.require: I6H5MH
240 */
241 HWTEST_F(CloudDiskRdbUtilsTest, GetLongTest004, TestSize.Level1)
242 {
243 GTEST_LOG_(INFO) << "GetLong Start";
244 try {
245 const string key = FileColumn::FILE_SIZE;
246 int64_t value;
247 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
248 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
249 EXPECT_CALL(*resultSet, GetLong(_, _)).WillOnce(Return(E_RDB));
250 int32_t ret = CloudDiskRdbUtils::GetLong(key, value, resultSet);
251 EXPECT_EQ(ret, E_RDB);
252 } catch(...) {
253 EXPECT_TRUE(false);
254 GTEST_LOG_(INFO) << "GetLong ERROR";
255 }
256 GTEST_LOG_(INFO) << "GetLong End";
257 }
258
259 /**
260 * @tc.name: GetLongTest005
261 * @tc.desc: Verify the GetLong function.
262 * @tc.type: FUNC
263 * @tc.require: I6H5MH
264 */
265 HWTEST_F(CloudDiskRdbUtilsTest, GetLongTest005, TestSize.Level1)
266 {
267 GTEST_LOG_(INFO) << "GetLong Start";
268 try {
269 const string key = FileColumn::FILE_SIZE;
270 int64_t value;
271 std::shared_ptr<ResultSetMock> resultSet = nullptr;
272
273 int32_t ret = CloudDiskRdbUtils::GetLong(key, value, resultSet);
274 EXPECT_EQ(ret, E_RDB);
275 } catch(...) {
276 EXPECT_TRUE(false);
277 GTEST_LOG_(INFO) << "GetLong ERROR";
278 }
279 GTEST_LOG_(INFO) << "GetLong End";
280 }
281
282 /**
283 * @tc.name: GetStringTest001
284 * @tc.desc: Verify the GetString function.
285 * @tc.type: FUNC
286 * @tc.require: I6H5MH
287 */
288 HWTEST_F(CloudDiskRdbUtilsTest, GetStringTest001, TestSize.Level1)
289 {
290 GTEST_LOG_(INFO) << "GetString Start";
291 const string key = FileColumn::FILE_NAME;
292 string value;
293 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
294 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
295 EXPECT_CALL(*resultSet, GetString(_, _)).WillOnce(Return(E_OK));
296 int32_t ret = CloudDiskRdbUtils::GetString(key, value, resultSet);
297 EXPECT_EQ(ret, E_OK);
298 GTEST_LOG_(INFO) << "GetString End";
299 }
300
301 /**
302 * @tc.name: GetStringTest002
303 * @tc.desc: Verify the GetString function.
304 * @tc.type: FUNC
305 * @tc.require: I6H5MH
306 */
307 HWTEST_F(CloudDiskRdbUtilsTest, GetStringTest002, TestSize.Level1)
308 {
309 GTEST_LOG_(INFO) << "GetString Start";
310 try {
311 const string key = "";
312 string value;
313 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
314 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
315 EXPECT_CALL(*resultSet, GetString(_, _)).WillOnce(Return(E_OK));
316 int32_t ret = CloudDiskRdbUtils::GetString(key, value, resultSet);
317 EXPECT_EQ(ret, E_OK);
318 } catch(...) {
319 EXPECT_TRUE(false);
320 GTEST_LOG_(INFO) << "GetString ERROR";
321 }
322 GTEST_LOG_(INFO) << "GetString End";
323 }
324
325 /**
326 * @tc.name: GetStringTest003
327 * @tc.desc: Verify the GetString function.
328 * @tc.type: FUNC
329 * @tc.require: I6H5MH
330 */
331 HWTEST_F(CloudDiskRdbUtilsTest, GetStringTest003, TestSize.Level1)
332 {
333 GTEST_LOG_(INFO) << "GetString Start";
334 try {
335 const string key = FileColumn::FILE_NAME;
336 string value;
337 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
338 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_RDB));
339 int32_t ret = CloudDiskRdbUtils::GetString(key, value, resultSet);
340 EXPECT_EQ(ret, E_RDB);
341 } catch(...) {
342 EXPECT_TRUE(false);
343 GTEST_LOG_(INFO) << "GetString ERROR";
344 }
345 GTEST_LOG_(INFO) << "GetString End";
346 }
347
348 /**
349 * @tc.name: GetStringTest004
350 * @tc.desc: Verify the GetString function.
351 * @tc.type: FUNC
352 * @tc.require: I6H5MH
353 */
354 HWTEST_F(CloudDiskRdbUtilsTest, GetStringTest004, TestSize.Level1)
355 {
356 GTEST_LOG_(INFO) << "GetString Start";
357 try {
358 const string key = FileColumn::FILE_NAME;
359 string value;
360 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
361 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
362 EXPECT_CALL(*resultSet, GetString(_, _)).WillOnce(Return(E_RDB));
363 int32_t ret = CloudDiskRdbUtils::GetString(key, value, resultSet);
364 EXPECT_EQ(ret, E_RDB);
365 } catch(...) {
366 EXPECT_TRUE(false);
367 GTEST_LOG_(INFO) << "GetString ERROR";
368 }
369 GTEST_LOG_(INFO) << "GetString End";
370 }
371
372 /**
373 * @tc.name: GetStringTest005
374 * @tc.desc: Verify the GetString function.
375 * @tc.type: FUNC
376 * @tc.require: I6H5MH
377 */
378 HWTEST_F(CloudDiskRdbUtilsTest, GetStringTest005, TestSize.Level1)
379 {
380 GTEST_LOG_(INFO) << "GetString Start";
381 try {
382 const string key = FileColumn::FILE_NAME;
383 string value;
384 std::shared_ptr<ResultSetMock> resultSet = nullptr;
385
386 int32_t ret = CloudDiskRdbUtils::GetString(key, value, resultSet);
387 EXPECT_EQ(ret, E_RDB);
388 } catch(...) {
389 EXPECT_TRUE(false);
390 GTEST_LOG_(INFO) << "GetString ERROR";
391 }
392 GTEST_LOG_(INFO) << "GetString End";
393 }
394
395 /**
396 * @tc.name: ResultSetToFileInfoTest001
397 * @tc.desc: Verify the ResultSetToFileInfo function.
398 * @tc.type: FUNC
399 * @tc.require: I6H5MH
400 */
401 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfoTest001, TestSize.Level1)
402 {
403 GTEST_LOG_(INFO) << "ResultSetToFileInfo Start";
404 try {
405 CloudDiskFileInfo info;
406 std::shared_ptr<ResultSet> resultSet = nullptr;
407 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfo(resultSet, info);
408 EXPECT_EQ(ret, E_RDB);
409 } catch(...) {
410 EXPECT_TRUE(false);
411 GTEST_LOG_(INFO) << "ResultSetToFileInfo ERROR";
412 }
413 GTEST_LOG_(INFO) << "ResultSetToFileInfo End";
414 }
415
416 /**
417 * @tc.name: ResultSetToFileInfoTest002
418 * @tc.desc: Verify the ResultSetToFileInfo function.
419 * @tc.type: FUNC
420 * @tc.require: I6H5MH
421 */
422 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfoTest002, TestSize.Level1)
423 {
424 GTEST_LOG_(INFO) << "ResultSetToFileInfo Start";
425 try {
426 CloudDiskFileInfo info;
427 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
428 EXPECT_CALL(*resultSet, GoToNextRow()).WillOnce(Return(E_RDB));
429 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfo(std::move(resultSet), info);
430 EXPECT_EQ(ret, E_RDB);
431 } catch(...) {
432 EXPECT_TRUE(false);
433 GTEST_LOG_(INFO) << "ResultSetToFileInfo ERROR";
434 }
435 GTEST_LOG_(INFO) << "ResultSetToFileInfo End";
436 }
437
438 /**
439 * @tc.name: ResultSetToFileInfoTest003
440 * @tc.desc: Verify the ResultSetToFileInfo function.
441 * @tc.type: FUNC
442 * @tc.require: I6H5MH
443 */
444 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfoTest003, TestSize.Level1)
445 {
446 GTEST_LOG_(INFO) << "ResultSetToFileInfo Start";
447 try {
448 CloudDiskFileInfo info;
449 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
450 EXPECT_CALL(*resultSet, GoToNextRow()).WillOnce(Return(E_OK));
451 EXPECT_CALL(*resultSet, GetRow(_)).WillOnce(Return(E_RDB));
452 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfo(std::move(resultSet), info);
453 EXPECT_EQ(ret, E_RDB);
454 } catch(...) {
455 EXPECT_TRUE(false);
456 GTEST_LOG_(INFO) << "ResultSetToFileInfo ERROR";
457 }
458 GTEST_LOG_(INFO) << "ResultSetToFileInfo End";
459 }
460
461 /**
462 * @tc.name: ResultSetToFileInfoTest004
463 * @tc.desc: Verify the ResultSetToFileInfo function.
464 * @tc.type: FUNC
465 * @tc.require: I6H5MH
466 */
467 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfoTest004, TestSize.Level1)
468 {
469 GTEST_LOG_(INFO) << "ResultSetToFileInfo Start";
470 CloudDiskFileInfo info;
471 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
472 EXPECT_CALL(*resultSet, GoToNextRow()).WillOnce(Return(E_OK));
473 EXPECT_CALL(*resultSet, GetRow(_)).WillOnce(Return(E_OK));
474 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfo(std::move(resultSet), info);
475 EXPECT_EQ(ret, E_OK);
476 GTEST_LOG_(INFO) << "ResultSetToFileInfo End";
477 }
478
479 /**
480 * @tc.name: ResultSetToFileInfosTest001
481 * @tc.desc: Verify the ResultSetToFileInfos function.
482 * @tc.type: FUNC
483 * @tc.require: I6H5MH
484 */
485 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfosTest001, TestSize.Level1)
486 {
487 GTEST_LOG_(INFO) << "ResultSetToFileInfos Start";
488 try {
489 vector<CloudDiskFileInfo> infos;
490 std::shared_ptr<ResultSet> resultSet = nullptr;
491 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfos(resultSet, infos);
492 EXPECT_EQ(ret, E_RDB);
493 } catch(...) {
494 EXPECT_TRUE(false);
495 GTEST_LOG_(INFO) << "ResultSetToFileInfos ERROR";
496 }
497 GTEST_LOG_(INFO) << "ResultSetToFileInfos End";
498 }
499
500 /**
501 * @tc.name: ResultSetToFileInfosTest002
502 * @tc.desc: Verify the ResultSetToFileInfos function.
503 * @tc.type: FUNC
504 * @tc.require: I6H5MH
505 */
506 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfosTest002, TestSize.Level1)
507 {
508 GTEST_LOG_(INFO) << "ResultSetToFileInfos Start";
509 vector<CloudDiskFileInfo> infos;
510 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
511 EXPECT_CALL(*resultSet, GoToNextRow()).WillOnce(Return(E_RDB));
512 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfos(std::move(resultSet), infos);
513 EXPECT_EQ(ret, E_OK);
514 GTEST_LOG_(INFO) << "ResultSetToFileInfos End";
515 }
516
517 /**
518 * @tc.name: ResultSetToFileInfosTest003
519 * @tc.desc: Verify the ResultSetToFileInfos function.
520 * @tc.type: FUNC
521 * @tc.require: I6H5MH
522 */
523 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfosTest003, TestSize.Level1)
524 {
525 GTEST_LOG_(INFO) << "ResultSetToFileInfos Start";
526 vector<CloudDiskFileInfo> infos;
527 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
528 EXPECT_CALL(*resultSet, GoToNextRow())
529 .Times(2)
530 .WillOnce(Return(E_OK))
531 .WillOnce(Return(E_RDB));
532 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).Times(2).WillRepeatedly(Return(E_OK));
533 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfos(std::move(resultSet), infos);
534 EXPECT_EQ(ret, E_OK);
535 GTEST_LOG_(INFO) << "ResultSetToFileInfos End";
536 }
537
538 } // namespace Test
539 } // namespace FileManagement::CloudSync
540 } // namespace OHOS
541