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 /**
150 * @tc.name: GetLongTest001
151 * @tc.desc: Verify the GetLong function.
152 * @tc.type: FUNC
153 * @tc.require: I6H5MH
154 */
155 HWTEST_F(CloudDiskRdbUtilsTest, GetLongTest001, TestSize.Level1)
156 {
157 GTEST_LOG_(INFO) << "GetLong Start";
158 const string key = FileColumn::FILE_SIZE;
159 int64_t value;
160 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
161 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
162 EXPECT_CALL(*resultSet, GetLong(_, _)).WillOnce(Return(E_OK));
163 int32_t ret = CloudDiskRdbUtils::GetLong(key, value, std::move(resultSet));
164 EXPECT_EQ(ret, E_OK);
165 GTEST_LOG_(INFO) << "GetLong End";
166 }
167
168 /**
169 * @tc.name: GetLongTest002
170 * @tc.desc: Verify the GetLong function.
171 * @tc.type: FUNC
172 * @tc.require: I6H5MH
173 */
174 HWTEST_F(CloudDiskRdbUtilsTest, GetLongTest002, TestSize.Level1)
175 {
176 GTEST_LOG_(INFO) << "GetLong Start";
177 try {
178 const string key = "";
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 } catch(...) {
186 EXPECT_TRUE(false);
187 GTEST_LOG_(INFO) << " GetLong ERROR";
188 }
189 GTEST_LOG_(INFO) << "GetLong End";
190 }
191
192 /**
193 * @tc.name: GetLongTest003
194 * @tc.desc: Verify the GetLong function.
195 * @tc.type: FUNC
196 * @tc.require: I6H5MH
197 */
198 HWTEST_F(CloudDiskRdbUtilsTest, GetLongTest003, TestSize.Level1)
199 {
200 GTEST_LOG_(INFO) << "GetLong Start";
201 try {
202 const string key = FileColumn::FILE_SIZE;
203 int64_t value;
204 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
205 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_RDB));
206 int32_t ret = CloudDiskRdbUtils::GetLong(key, value, resultSet);
207 EXPECT_EQ(ret, E_RDB);
208 } catch(...) {
209 EXPECT_TRUE(false);
210 GTEST_LOG_(INFO) << " GetLong ERROR";
211 }
212 GTEST_LOG_(INFO) << "GetLong End";
213 }
214
215 /**
216 * @tc.name: GetLongTest004
217 * @tc.desc: Verify the GetLong function.
218 * @tc.type: FUNC
219 * @tc.require: I6H5MH
220 */
221 HWTEST_F(CloudDiskRdbUtilsTest, GetLongTest004, TestSize.Level1)
222 {
223 GTEST_LOG_(INFO) << "GetLong Start";
224 try {
225 const string key = FileColumn::FILE_SIZE;
226 int64_t value;
227 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
228 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
229 EXPECT_CALL(*resultSet, GetLong(_, _)).WillOnce(Return(E_RDB));
230 int32_t ret = CloudDiskRdbUtils::GetLong(key, value, resultSet);
231 EXPECT_EQ(ret, E_RDB);
232 } catch(...) {
233 EXPECT_TRUE(false);
234 GTEST_LOG_(INFO) << "GetLong ERROR";
235 }
236 GTEST_LOG_(INFO) << "GetLong End";
237 }
238
239 /**
240 * @tc.name: GetStringTest001
241 * @tc.desc: Verify the GetString function.
242 * @tc.type: FUNC
243 * @tc.require: I6H5MH
244 */
245 HWTEST_F(CloudDiskRdbUtilsTest, GetStringTest001, TestSize.Level1)
246 {
247 GTEST_LOG_(INFO) << "GetString Start";
248 const string key = FileColumn::FILE_NAME;
249 string value;
250 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
251 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
252 EXPECT_CALL(*resultSet, GetString(_, _)).WillOnce(Return(E_OK));
253 int32_t ret = CloudDiskRdbUtils::GetString(key, value, resultSet);
254 EXPECT_EQ(ret, E_OK);
255 GTEST_LOG_(INFO) << "GetString End";
256 }
257
258 /**
259 * @tc.name: GetStringTest002
260 * @tc.desc: Verify the GetString function.
261 * @tc.type: FUNC
262 * @tc.require: I6H5MH
263 */
264 HWTEST_F(CloudDiskRdbUtilsTest, GetStringTest002, TestSize.Level1)
265 {
266 GTEST_LOG_(INFO) << "GetString Start";
267 try {
268 const string key = "";
269 string value;
270 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
271 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
272 EXPECT_CALL(*resultSet, GetString(_, _)).WillOnce(Return(E_OK));
273 int32_t ret = CloudDiskRdbUtils::GetString(key, value, resultSet);
274 EXPECT_EQ(ret, E_OK);
275 } catch(...) {
276 EXPECT_TRUE(false);
277 GTEST_LOG_(INFO) << "GetString ERROR";
278 }
279 GTEST_LOG_(INFO) << "GetString End";
280 }
281
282 /**
283 * @tc.name: GetStringTest003
284 * @tc.desc: Verify the GetString function.
285 * @tc.type: FUNC
286 * @tc.require: I6H5MH
287 */
288 HWTEST_F(CloudDiskRdbUtilsTest, GetStringTest003, TestSize.Level1)
289 {
290 GTEST_LOG_(INFO) << "GetString Start";
291 try {
292 const string key = FileColumn::FILE_NAME;
293 string value;
294 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
295 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_RDB));
296 int32_t ret = CloudDiskRdbUtils::GetString(key, value, resultSet);
297 EXPECT_EQ(ret, E_RDB);
298 } catch(...) {
299 EXPECT_TRUE(false);
300 GTEST_LOG_(INFO) << "GetString ERROR";
301 }
302 GTEST_LOG_(INFO) << "GetString End";
303 }
304
305 /**
306 * @tc.name: GetStringTest004
307 * @tc.desc: Verify the GetString function.
308 * @tc.type: FUNC
309 * @tc.require: I6H5MH
310 */
311 HWTEST_F(CloudDiskRdbUtilsTest, GetStringTest004, TestSize.Level1)
312 {
313 GTEST_LOG_(INFO) << "GetString Start";
314 try {
315 const string key = FileColumn::FILE_NAME;
316 string value;
317 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
318 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
319 EXPECT_CALL(*resultSet, GetString(_, _)).WillOnce(Return(E_RDB));
320 int32_t ret = CloudDiskRdbUtils::GetString(key, value, resultSet);
321 EXPECT_EQ(ret, E_RDB);
322 } catch(...) {
323 EXPECT_TRUE(false);
324 GTEST_LOG_(INFO) << "GetString ERROR";
325 }
326 GTEST_LOG_(INFO) << "GetString End";
327 }
328
329 /**
330 * @tc.name: ResultSetToFileInfoTest001
331 * @tc.desc: Verify the ResultSetToFileInfo function.
332 * @tc.type: FUNC
333 * @tc.require: I6H5MH
334 */
335 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfoTest001, TestSize.Level1)
336 {
337 GTEST_LOG_(INFO) << "ResultSetToFileInfo Start";
338 try {
339 CloudDiskFileInfo info;
340 std::shared_ptr<ResultSet> resultSet = nullptr;
341 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfo(resultSet, info);
342 EXPECT_EQ(ret, E_RDB);
343 } catch(...) {
344 EXPECT_TRUE(false);
345 GTEST_LOG_(INFO) << "ResultSetToFileInfo ERROR";
346 }
347 GTEST_LOG_(INFO) << "ResultSetToFileInfo End";
348 }
349
350 /**
351 * @tc.name: ResultSetToFileInfoTest002
352 * @tc.desc: Verify the ResultSetToFileInfo function.
353 * @tc.type: FUNC
354 * @tc.require: I6H5MH
355 */
356 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfoTest002, TestSize.Level1)
357 {
358 GTEST_LOG_(INFO) << "ResultSetToFileInfo Start";
359 try {
360 CloudDiskFileInfo info;
361 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
362 EXPECT_CALL(*resultSet, GoToNextRow()).WillOnce(Return(E_RDB));
363 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfo(std::move(resultSet), info);
364 EXPECT_EQ(ret, E_RDB);
365 } catch(...) {
366 EXPECT_TRUE(false);
367 GTEST_LOG_(INFO) << "ResultSetToFileInfo ERROR";
368 }
369 GTEST_LOG_(INFO) << "ResultSetToFileInfo End";
370 }
371
372 /**
373 * @tc.name: ResultSetToFileInfoTest003
374 * @tc.desc: Verify the ResultSetToFileInfo function.
375 * @tc.type: FUNC
376 * @tc.require: I6H5MH
377 */
378 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfoTest003, TestSize.Level1)
379 {
380 GTEST_LOG_(INFO) << "ResultSetToFileInfo Start";
381 try {
382 CloudDiskFileInfo info;
383 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
384 EXPECT_CALL(*resultSet, GoToNextRow()).WillOnce(Return(E_OK));
385 EXPECT_CALL(*resultSet, GetRow(_)).WillOnce(Return(E_RDB));
386 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfo(std::move(resultSet), info);
387 EXPECT_EQ(ret, E_RDB);
388 } catch(...) {
389 EXPECT_TRUE(false);
390 GTEST_LOG_(INFO) << "ResultSetToFileInfo ERROR";
391 }
392 GTEST_LOG_(INFO) << "ResultSetToFileInfo End";
393 }
394
395 /**
396 * @tc.name: ResultSetToFileInfoTest004
397 * @tc.desc: Verify the ResultSetToFileInfo function.
398 * @tc.type: FUNC
399 * @tc.require: I6H5MH
400 */
401 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfoTest004, TestSize.Level1)
402 {
403 GTEST_LOG_(INFO) << "ResultSetToFileInfo Start";
404 CloudDiskFileInfo info;
405 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
406 EXPECT_CALL(*resultSet, GoToNextRow()).WillOnce(Return(E_OK));
407 EXPECT_CALL(*resultSet, GetRow(_)).WillOnce(Return(E_OK));
408 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfo(std::move(resultSet), info);
409 EXPECT_EQ(ret, E_OK);
410 GTEST_LOG_(INFO) << "ResultSetToFileInfo End";
411 }
412
413 /**
414 * @tc.name: ResultSetToFileInfosTest001
415 * @tc.desc: Verify the ResultSetToFileInfos function.
416 * @tc.type: FUNC
417 * @tc.require: I6H5MH
418 */
419 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfosTest001, TestSize.Level1)
420 {
421 GTEST_LOG_(INFO) << "ResultSetToFileInfos Start";
422 try {
423 vector<CloudDiskFileInfo> infos;
424 std::shared_ptr<ResultSet> resultSet = nullptr;
425 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfos(resultSet, infos);
426 EXPECT_EQ(ret, E_RDB);
427 } catch(...) {
428 EXPECT_TRUE(false);
429 GTEST_LOG_(INFO) << "ResultSetToFileInfos ERROR";
430 }
431 GTEST_LOG_(INFO) << "ResultSetToFileInfos End";
432 }
433
434 /**
435 * @tc.name: ResultSetToFileInfosTest002
436 * @tc.desc: Verify the ResultSetToFileInfos function.
437 * @tc.type: FUNC
438 * @tc.require: I6H5MH
439 */
440 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfosTest002, TestSize.Level1)
441 {
442 GTEST_LOG_(INFO) << "ResultSetToFileInfos Start";
443 vector<CloudDiskFileInfo> infos;
444 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
445 EXPECT_CALL(*resultSet, GoToNextRow()).WillOnce(Return(E_RDB));
446 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfos(std::move(resultSet), infos);
447 EXPECT_EQ(ret, E_OK);
448 GTEST_LOG_(INFO) << "ResultSetToFileInfos End";
449 }
450
451 /**
452 * @tc.name: ResultSetToFileInfosTest003
453 * @tc.desc: Verify the ResultSetToFileInfos function.
454 * @tc.type: FUNC
455 * @tc.require: I6H5MH
456 */
457 HWTEST_F(CloudDiskRdbUtilsTest, ResultSetToFileInfosTest003, TestSize.Level1)
458 {
459 GTEST_LOG_(INFO) << "ResultSetToFileInfos Start";
460 vector<CloudDiskFileInfo> infos;
461 std::shared_ptr<ResultSetMock> resultSet = std::make_shared<ResultSetMock>();
462 EXPECT_CALL(*resultSet, GoToNextRow())
463 .Times(2)
464 .WillOnce(Return(E_OK))
465 .WillOnce(Return(E_RDB));
466 EXPECT_CALL(*resultSet, GetColumnIndex(_, _)).Times(2).WillRepeatedly(Return(E_OK));
467 int32_t ret = CloudDiskRdbUtils::ResultSetToFileInfos(std::move(resultSet), infos);
468 EXPECT_EQ(ret, E_OK);
469 GTEST_LOG_(INFO) << "ResultSetToFileInfos End";
470 }
471
472 } // namespace Test
473 } // namespace FileManagement::CloudSync
474 } // namespace OHOS
475