• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  /**
17  * @tc.name: QueryAndDeleteMap001
18  * @tc.desc: Verify the QueryAndDeleteMap001 function
19  * @tc.type: FUNC
20  * @tc.require: issueI8ARMY
21  */
22 
23 #include <memory>
24 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap001, TestSize.Level1)
25 {
26     GTEST_LOG_(INFO) << "QueryAndDeleteMap001 Begin";
27     try {
28         auto rdb = std::make_shared<RdbStoreMock>();
29         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
30         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(nullptr));
31 
32         int32_t fileId = 0;
33         const set<int> cloudMapIds;
34         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
35         EXPECT_TRUE(true);
36     } catch (...) {
37         EXPECT_TRUE(false);
38         GTEST_LOG_(INFO) << " QueryAndDeleteMap001 ERROR";
39     }
40     GTEST_LOG_(INFO) << "QueryAndDeleteMap001 End";
41 }
42 
43 /**
44  * @tc.name: QueryAndDeleteMap002
45  * @tc.desc: Verify the QueryAndDeleteMap002 function
46  * @tc.type: FUNC
47  * @tc.require: issueI8ARMY
48  */
49 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap002, TestSize.Level1)
50 {
51     GTEST_LOG_(INFO) << "QueryAndDeleteMap002 Begin";
52     try {
53         const int32_t rowCount = -1;
54         auto rdb = std::make_shared<RdbStoreMock>();
55         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
56         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
57         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(1)));
58         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
59 
60         int32_t fileId = 0;
61         const set<int> cloudMapIds;
62         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
63         EXPECT_TRUE(true);
64     } catch (...) {
65         EXPECT_TRUE(false);
66         GTEST_LOG_(INFO) << " QueryAndDeleteMap002 ERROR";
67     }
68     GTEST_LOG_(INFO) << "QueryAndDeleteMap002 End";
69 }
70 
71 /**
72  * @tc.name: QueryAndDeleteMap003
73  * @tc.desc: Verify the QueryAndDeleteMap003 function
74  * @tc.type: FUNC
75  * @tc.require: issueI8ARMY
76  */
77 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap003, TestSize.Level1)
78 {
79     GTEST_LOG_(INFO) << "QueryAndDeleteMap003 Begin";
80     try {
81         const int32_t rowCount = -1;
82         auto rdb = std::make_shared<RdbStoreMock>();
83         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
84         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
85         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
86         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
87 
88         int32_t fileId = 0;
89         const set<int> cloudMapIds;
90         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
91         EXPECT_TRUE(true);
92     } catch (...) {
93         EXPECT_TRUE(false);
94         GTEST_LOG_(INFO) << " QueryAndDeleteMap003 ERROR";
95     }
96     GTEST_LOG_(INFO) << "QueryAndDeleteMap003 End";
97 }
98 
99 /**
100  * @tc.name: QueryAndDeleteMap004
101  * @tc.desc: Verify the QueryAndDeleteMap004 function
102  * @tc.type: FUNC
103  * @tc.require: issueI8ARMY
104  */
105 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap004, TestSize.Level1)
106 {
107     GTEST_LOG_(INFO) << "QueryAndDeleteMap004 Begin";
108     try {
109         const int32_t rowCount = 0;
110         auto rdb = std::make_shared<RdbStoreMock>();
111         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
112         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
113         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
114         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
115         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
116 
117         int32_t fileId = 0;
118         const set<int> cloudMapIds;
119         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
120         EXPECT_TRUE(true);
121     } catch (...) {
122         EXPECT_TRUE(false);
123         GTEST_LOG_(INFO) << " QueryAndDeleteMap004 ERROR";
124     }
125     GTEST_LOG_(INFO) << "QueryAndDeleteMap004 End";
126 }
127 
128 /**
129  * @tc.name: QueryAndDeleteMap005
130  * @tc.desc: Verify the QueryAndDeleteMap005 function
131  * @tc.type: FUNC
132  * @tc.require: issueI8ARMY
133  */
134 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap005, TestSize.Level1)
135 {
136     GTEST_LOG_(INFO) << "QueryAndDeleteMap005 Begin";
137     try {
138         const int32_t rowCount = 1;
139         auto rdb = std::make_shared<RdbStoreMock>();
140         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
141         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
142         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
143         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
144         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
145 
146         int32_t fileId = 0;
147         const set<int> cloudMapIds;
148         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
149         EXPECT_TRUE(true);
150     } catch (...) {
151         EXPECT_TRUE(false);
152         GTEST_LOG_(INFO) << " QueryAndDeleteMap005 ERROR";
153     }
154     GTEST_LOG_(INFO) << "QueryAndDeleteMap005 End";
155 }
156 
157 /**
158  * @tc.name: QueryAndDeleteMap006
159  * @tc.desc: Verify the QueryAndDeleteMap006 function
160  * @tc.type: FUNC
161  * @tc.require: issueI8ARMY
162  */
163 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap006, TestSize.Level1)
164 {
165     GTEST_LOG_(INFO) << "QueryAndDeleteMap006 Begin";
166     try {
167         const int32_t rowCount = 1;
168         auto rdb = std::make_shared<RdbStoreMock>();
169         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
170         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
171         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
172         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1));
173         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
174         EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(1));
175         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
176 
177         int32_t fileId = 0;
178         const set<int> cloudMapIds;
179         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
180         EXPECT_TRUE(true);
181     } catch (...) {
182         EXPECT_TRUE(false);
183         GTEST_LOG_(INFO) << " QueryAndDeleteMap006 ERROR";
184     }
185     GTEST_LOG_(INFO) << "QueryAndDeleteMap006 End";
186 }
187 
188 /**
189  * @tc.name: QueryAndDeleteMap007
190  * @tc.desc: Verify the QueryAndDeleteMap007 function
191  * @tc.type: FUNC
192  * @tc.require: issueI8ARMY
193  */
194 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap007, TestSize.Level1)
195 {
196     GTEST_LOG_(INFO) << "QueryAndDeleteMap007 Begin";
197     try {
198         const int32_t rowCount = 1;
199         auto rdb = std::make_shared<RdbStoreMock>();
200         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
201         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
202         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
203         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1));
204         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
205         EXPECT_CALL(*rset, GetInt(_, _)).WillOnce(Return(0)).WillOnce(Return(1));
206         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
207 
208         int32_t fileId = 0;
209         const set<int> cloudMapIds;
210         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
211         EXPECT_TRUE(true);
212     } catch (...) {
213         EXPECT_TRUE(false);
214         GTEST_LOG_(INFO) << " QueryAndDeleteMap007 ERROR";
215     }
216     GTEST_LOG_(INFO) << "QueryAndDeleteMap007 End";
217 }
218 
219 /**
220  * @tc.name: QueryAndDeleteMap008
221  * @tc.desc: Verify the QueryAndDeleteMap008 function
222  * @tc.type: FUNC
223  * @tc.require: issueI8ARMY
224  */
225 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap008, TestSize.Level1)
226 {
227     GTEST_LOG_(INFO) << "QueryAndDeleteMap008 Begin";
228     try {
229         const int32_t rowCount = 1;
230         auto rdb = std::make_shared<RdbStoreMock>();
231         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
232         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
233         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
234         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1));
235         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
236         EXPECT_CALL(*rset, GetInt(_, _)).WillOnce(Return(0)).WillOnce(Return(0));
237         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
238         EXPECT_CALL(*rdb, Delete(_, _, _, A<const vector<string> &>())).WillOnce(Return(0));
239 
240         int32_t fileId = 0;
241         const set<int> cloudMapIds;
242         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
243         EXPECT_TRUE(true);
244     } catch (...) {
245         EXPECT_TRUE(false);
246         GTEST_LOG_(INFO) << " QueryAndDeleteMap008 ERROR";
247     }
248     GTEST_LOG_(INFO) << "QueryAndDeleteMap008 End";
249 }
250 
251 /**
252  * @tc.name: QueryAndDeleteMap009
253  * @tc.desc: Verify the QueryAndDeleteMap009 function
254  * @tc.type: FUNC
255  * @tc.require: issueI8ARMY
256  */
257 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap009, TestSize.Level1)
258 {
259     GTEST_LOG_(INFO) << "QueryAndDeleteMap009 Begin";
260     try {
261         const int32_t rowCount = 1;
262         const int32_t localDirty = static_cast<int32_t>(Media::DirtyTypes::TYPE_SYNCED);
263         auto rdb = std::make_shared<RdbStoreMock>();
264         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
265         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
266         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
267         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1));
268         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
269         EXPECT_CALL(*rset, GetInt(_, _))
270             .WillOnce(Return(0))
271             .WillOnce(DoAll(SetArgReferee<1>(localDirty), Return(0)));
272         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
273         EXPECT_CALL(*rdb, Delete(_, _, _, A<const vector<string> &>())).WillOnce(Return(0));
274 
275         int32_t fileId = 0;
276         const set<int> cloudMapIds;
277         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
278         EXPECT_TRUE(true);
279     } catch (...) {
280         EXPECT_TRUE(false);
281         GTEST_LOG_(INFO) << " QueryAndDeleteMap009 ERROR";
282     }
283     GTEST_LOG_(INFO) << "QueryAndDeleteMap009 End";
284 }
285 
286 /**
287  * @tc.name: QueryAndDeleteMap010
288  * @tc.desc: Verify the QueryAndDeleteMap010 function
289  * @tc.type: FUNC
290  * @tc.require: issueI8ARMY
291  */
292 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap010, TestSize.Level1)
293 {
294     GTEST_LOG_(INFO) << "QueryAndDeleteMap010 Begin";
295     try {
296         const int32_t rowCount = 1;
297         const int32_t localDirty = static_cast<int32_t>(Media::DirtyTypes::TYPE_SYNCED);
298         auto rdb = std::make_shared<RdbStoreMock>();
299         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
300         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
301         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
302         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1));
303         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
304         EXPECT_CALL(*rset, GetInt(_, _))
305             .WillOnce(DoAll(SetArgReferee<1>(1), Return(0)))
306             .WillOnce(DoAll(SetArgReferee<1>(localDirty), Return(0)));
307         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
308         EXPECT_CALL(*rdb, Delete(_, _, _, A<const vector<string> &>())).WillRepeatedly(Return(-1));
309 
310         int32_t fileId = 0;
311         std::set<int> cloudMapIds;
312         cloudMapIds.insert(1);
313         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
314         EXPECT_TRUE(true);
315     } catch (...) {
316         EXPECT_TRUE(false);
317         GTEST_LOG_(INFO) << " QueryAndDeleteMap010 ERROR";
318     }
319     GTEST_LOG_(INFO) << "QueryAndDeleteMap010 End";
320 }
321 
322 /**
323  * @tc.name: QueryAndDeleteMap011
324  * @tc.desc: Verify the QueryAndDeleteMap011 function
325  * @tc.type: FUNC
326  * @tc.require: issueI8ARMY
327  */
328 HWTEST_F(FileDataHandlerTest, QueryAndDeleteMap011, TestSize.Level1)
329 {
330     GTEST_LOG_(INFO) << "QueryAndDeleteMap011 Begin";
331     try {
332         const int32_t rowCount = 1;
333         const int32_t localDirty = static_cast<int32_t>(Media::DirtyTypes::TYPE_SYNCED);
334         auto rdb = std::make_shared<RdbStoreMock>();
335         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
336         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
337         EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
338         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1));
339         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
340         EXPECT_CALL(*rset, GetInt(_, _))
341             .WillOnce(DoAll(SetArgReferee<1>(1), Return(0)))
342             .WillOnce(DoAll(SetArgReferee<1>(localDirty), Return(0)));
343         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
344         EXPECT_CALL(*rdb, Delete(_, _, _, A<const vector<string> &>())).WillRepeatedly(Return(0));
345 
346         int32_t fileId = 0;
347         std::set<int> cloudMapIds;
348         cloudMapIds.insert(1);
349         fileDataHandler->QueryAndDeleteMap(fileId, cloudMapIds);
350         EXPECT_TRUE(true);
351     } catch (...) {
352         EXPECT_TRUE(false);
353         GTEST_LOG_(INFO) << " QueryAndDeleteMap011 ERROR";
354     }
355     GTEST_LOG_(INFO) << "QueryAndDeleteMap011 End";
356 }
357 
358 /**
359  * @tc.name: BatchInsertAssetMaps001
360  * @tc.desc: Verify the BatchInsertAssetMaps001 function
361  * @tc.type: FUNC
362  * @tc.require: issueI8ARMY
363  */
364 HWTEST_F(FileDataHandlerTest, BatchInsertAssetMaps001, TestSize.Level1)
365 {
366     GTEST_LOG_(INFO) << "BatchInsertAssetMaps001 Begin";
367     try {
368         auto rdb = std::make_shared<RdbStoreMock>();
369         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
370         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(nullptr));
371 
372         OnFetchParams params;
373         int32_t ret = fileDataHandler->BatchInsertAssetMaps(params);
374         EXPECT_EQ(ret, E_RDB);
375     } catch (...) {
376         EXPECT_TRUE(false);
377         GTEST_LOG_(INFO) << " BatchInsertAssetMaps001 ERROR";
378     }
379     GTEST_LOG_(INFO) << "BatchInsertAssetMaps001 End";
380 }
381 
382 /**
383  * @tc.name: BatchInsertAssetMaps002
384  * @tc.desc: Verify the BatchInsertAssetMaps002 function
385  * @tc.type: FUNC
386  * @tc.require: issueI8ARMY
387  */
388 HWTEST_F(FileDataHandlerTest, BatchInsertAssetMaps002, TestSize.Level1)
389 {
390     GTEST_LOG_(INFO) << "BatchInsertAssetMaps002 Begin";
391     try {
392         const int32_t rowCount = 1;
393         auto rdb = std::make_shared<RdbStoreMock>();
394         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
395         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
396         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
397         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
398         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0));
399         EXPECT_CALL(*rset, GetString(_, _)).WillOnce(DoAll(SetArgReferee<1>("1"), Return(0)));
400         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
401 
402         OnFetchParams params;
403         int32_t ret = fileDataHandler->BatchInsertAssetMaps(params);
404         EXPECT_EQ(ret, E_OK);
405     } catch (...) {
406         EXPECT_TRUE(false);
407         GTEST_LOG_(INFO) << " BatchInsertAssetMaps002 ERROR";
408     }
409     GTEST_LOG_(INFO) << "BatchInsertAssetMaps002 End";
410 }
411 
412 /**
413  * @tc.name: BatchInsertAssetMaps003
414  * @tc.desc: Verify the BatchInsertAssetMaps003 function
415  * @tc.type: FUNC
416  * @tc.require: issueI8ARMY
417  */
418 HWTEST_F(FileDataHandlerTest, BatchInsertAssetMaps003, TestSize.Level1)
419 {
420     GTEST_LOG_(INFO) << "BatchInsertAssetMaps003 Begin";
421     try {
422         const int32_t rowCount = 1;
423         auto rdb = std::make_shared<RdbStoreMock>();
424         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
425         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
426         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
427         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
428         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0));
429         EXPECT_CALL(*rset, GetString(_, _)).WillOnce(DoAll(SetArgReferee<1>("1"), Return(0)));
430         EXPECT_CALL(*rset, GoToRow(_)).WillOnce(Return(0));
431         EXPECT_CALL(*rset, GetInt(_, _)).WillOnce(Return(1));
432         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
433 
434         std::set<int> albumIds;
435         OnFetchParams params;
436         params.recordAlbumMaps.insert(make_pair("1", std::move(albumIds)));
437         int32_t ret = fileDataHandler->BatchInsertAssetMaps(params);
438         EXPECT_EQ(ret, E_OK);
439     } catch (...) {
440         EXPECT_TRUE(false);
441         GTEST_LOG_(INFO) << " BatchInsertAssetMaps003 ERROR";
442     }
443     GTEST_LOG_(INFO) << "BatchInsertAssetMaps003 End";
444 }
445 
446 /**
447  * @tc.name: BatchInsertAssetMaps004
448  * @tc.desc: Verify the BatchInsertAssetMaps004 function
449  * @tc.type: FUNC
450  * @tc.require: issueI8ARMY
451  */
452 HWTEST_F(FileDataHandlerTest, BatchInsertAssetMaps004, TestSize.Level1)
453 {
454     GTEST_LOG_(INFO) << "BatchInsertAssetMaps004 Begin";
455     try {
456         const int32_t rowCount = 1;
457         auto rdb = std::make_shared<RdbStoreMock>();
458         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
459         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
460         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
461         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
462         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0));
463         EXPECT_CALL(*rset, GetString(_, _)).WillOnce(DoAll(SetArgReferee<1>("1"), Return(0)));
464         EXPECT_CALL(*rset, GoToRow(_)).WillOnce(Return(0));
465         EXPECT_CALL(*rset, GetInt(_, _)).WillOnce(Return(0));
466         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
467         EXPECT_CALL(*rdb, Insert(_, _, _)).WillOnce(Return(1));
468 
469         std::set<int> albumIds;
470         albumIds.insert(1);
471         OnFetchParams params;
472         params.recordAlbumMaps.insert(make_pair("1", std::move(albumIds)));
473         int32_t ret = fileDataHandler->BatchInsertAssetMaps(params);
474         EXPECT_EQ(ret, E_OK);
475     } catch (...) {
476         EXPECT_TRUE(false);
477         GTEST_LOG_(INFO) << " BatchInsertAssetMaps004 ERROR";
478     }
479     GTEST_LOG_(INFO) << "BatchInsertAssetMaps004 End";
480 }
481 
482 /**
483  * @tc.name: BatchInsertAssetMaps005
484  * @tc.desc: Verify the BatchInsertAssetMaps005 function
485  * @tc.type: FUNC
486  * @tc.require: issueI8ARMY
487  */
488 HWTEST_F(FileDataHandlerTest, BatchInsertAssetMaps005, TestSize.Level1)
489 {
490     GTEST_LOG_(INFO) << "BatchInsertAssetMaps005 Begin";
491     try {
492         const int32_t rowCount = 1;
493         auto rdb = std::make_shared<RdbStoreMock>();
494         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
495         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
496         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
497         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
498         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0));
499         EXPECT_CALL(*rset, GetString(_, _)).WillOnce(DoAll(SetArgReferee<1>("1"), Return(0)));
500         EXPECT_CALL(*rset, GoToRow(_)).WillOnce(Return(0));
501         EXPECT_CALL(*rset, GetInt(_, _)).WillOnce(Return(0));
502         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
503         EXPECT_CALL(*rdb, Insert(_, _, _)).WillOnce(Return(0));
504 
505         std::set<int> albumIds;
506         albumIds.insert(1);
507         OnFetchParams params;
508         params.recordAlbumMaps.insert(make_pair("1", std::move(albumIds)));
509         int32_t ret = fileDataHandler->BatchInsertAssetMaps(params);
510         EXPECT_EQ(ret, E_OK);
511     } catch (...) {
512         EXPECT_TRUE(false);
513         GTEST_LOG_(INFO) << " BatchInsertAssetMaps005 ERROR";
514     }
515     GTEST_LOG_(INFO) << "BatchInsertAssetMaps005 End";
516 }
517 
518 /**
519  * @tc.name: CleanPureCloudRecord002
520  * @tc.desc: Verify the CleanPureCloudRecord function
521  * @tc.type: FUNC
522  * @tc.require: issuesI8R3H3
523  */
524 HWTEST_F(FileDataHandlerTest, CleanPureCloudRecord002, TestSize.Level1)
525 {
526     GTEST_LOG_(INFO) << "CleanPureCloudRecord002 Begin";
527     try {
528         auto rdb = std::make_shared<RdbStoreMock>();
529         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
530         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(nullptr));
531 
532         int32_t ret = fileDataHandler->CleanPureCloudRecord();
533         EXPECT_EQ(E_RDB, ret);
534     } catch (...) {
535         EXPECT_TRUE(false);
536         GTEST_LOG_(INFO) << " CleanPureCloudRecord002 ERROR";
537     }
538 
539     GTEST_LOG_(INFO) << "CleanPureCloudRecord002 End";
540 }
541 
542 /**
543  * @tc.name: CleanPureCloudRecord003
544  * @tc.desc: Verify the CleanPureCloudRecord function
545  * @tc.type: FUNC
546  * @tc.require: issuesI8R3H3
547  */
548 HWTEST_F(FileDataHandlerTest, CleanPureCloudRecord003, TestSize.Level1)
549 {
550     GTEST_LOG_(INFO) << "CleanPureCloudRecord003 Begin";
551     try {
552         const int32_t rowCount = 0;
553         auto rdb = std::make_shared<RdbStoreMock>();
554         auto rset = std::make_unique<AbsSharedResultSetMock>();
555         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
556         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(1)));
557         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
558 
559         int32_t ret = fileDataHandler->CleanPureCloudRecord();
560         EXPECT_EQ(1, ret);
561     } catch (...) {
562         EXPECT_TRUE(false);
563         GTEST_LOG_(INFO) << " CleanPureCloudRecord003 ERROR";
564     }
565 
566     GTEST_LOG_(INFO) << "CleanPureCloudRecord003 End";
567 }
568 
569 /**
570  * @tc.name: CleanPureCloudRecord004
571  * @tc.desc: Verify the CleanPureCloudRecord function
572  * @tc.type: FUNC
573  * @tc.require: issuesI8R3H3
574  */
575 HWTEST_F(FileDataHandlerTest, CleanPureCloudRecord004, TestSize.Level1)
576 {
577     GTEST_LOG_(INFO) << "CleanPureCloudRecord004 Begin";
578     try {
579         const int32_t rowCount = -1;
580         auto rdb = std::make_shared<RdbStoreMock>();
581         auto rset = std::make_unique<AbsSharedResultSetMock>();
582         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
583         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
584         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
585 
586         int32_t ret = fileDataHandler->CleanPureCloudRecord();
587         EXPECT_EQ(E_OK, ret);
588     } catch (...) {
589         EXPECT_TRUE(false);
590         GTEST_LOG_(INFO) << " CleanPureCloudRecord004 ERROR";
591     }
592 
593     GTEST_LOG_(INFO) << "CleanPureCloudRecord004 End";
594 }
595 
596 /**
597  * @tc.name: CleanPureCloudRecord005
598  * @tc.desc: Verify the CleanPureCloudRecord function
599  * @tc.type: FUNC
600  * @tc.require: issuesI8R3H3
601  */
602 HWTEST_F(FileDataHandlerTest, CleanPureCloudRecord005, TestSize.Level1)
603 {
604     GTEST_LOG_(INFO) << "CleanPureCloudRecord005 Begin";
605     try {
606         const int32_t rowCount = 1;
607         auto rdb = std::make_shared<RdbStoreMock>();
608         auto rset = std::make_unique<AbsSharedResultSetMock>();
609         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
610         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
611         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
612         EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
613         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))).WillOnce(Return(nullptr));
614 
615         int32_t ret = fileDataHandler->CleanPureCloudRecord();
616         EXPECT_EQ(E_RDB, ret);
617     } catch (...) {
618         EXPECT_TRUE(false);
619         GTEST_LOG_(INFO) << " CleanPureCloudRecord005 ERROR";
620     }
621 
622     GTEST_LOG_(INFO) << "CleanPureCloudRecord005 End";
623 }
624 
625 /**
626  * @tc.name: CleanPureCloudRecord006
627  * @tc.desc: Verify the CleanPureCloudRecord function
628  * @tc.type: FUNC
629  * @tc.require: issuesI8R3H3
630  */
631 HWTEST_F(FileDataHandlerTest, CleanPureCloudRecord006, TestSize.Level1)
632 {
633     GTEST_LOG_(INFO) << "CleanPureCloudRecord006 Begin";
634     try {
635         const int32_t rowCount = 1;
636         string filePath = "/test/pareantPath/thumbPpath";
637         auto rdb = std::make_shared<RdbStoreMock>();
638         auto rset = std::make_unique<AbsSharedResultSetMock>();
639         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
640         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
641         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0));
642         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
643         EXPECT_CALL(*rset, GetString(_, _))
644             .WillOnce(DoAll(SetArgReferee<1>("1"), Return(1)))
645             .WillOnce(DoAll(SetArgReferee<1>(filePath), Return(1)));
646         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
647 
648         int32_t ret = fileDataHandler->CleanPureCloudRecord();
649         EXPECT_EQ(E_INVAL_ARG, ret);
650     } catch (...) {
651         EXPECT_TRUE(false);
652         GTEST_LOG_(INFO) << " CleanPureCloudRecord006 ERROR";
653     }
654 
655     GTEST_LOG_(INFO) << "CleanPureCloudRecord006 End";
656 }
657 
658 /**
659  * @tc.name: CleanPureCloudRecord007
660  * @tc.desc: Verify the CleanPureCloudRecord function
661  * @tc.type: FUNC
662  * @tc.require: issuesI8R3H3
663  */
664 HWTEST_F(FileDataHandlerTest, CleanPureCloudRecord007, TestSize.Level1)
665 {
666     GTEST_LOG_(INFO) << "CleanPureCloudRecord007 Begin";
667     try {
668         const int32_t rowCount = 0;
669         string filePath = "/test/pareantPath/thumbPpath";
670         auto rdb = std::make_shared<RdbStoreMock>();
671         auto rset = std::make_unique<AbsSharedResultSetMock>();
672         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
673         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
674         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1));
675         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
676         EXPECT_CALL(*rset, GetString(_, _))
677             .WillOnce(DoAll(SetArgReferee<1>("1"), Return(1)))
678             .WillOnce(DoAll(SetArgReferee<1>(filePath), Return(0)));
679         EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
680         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
681 
682         int32_t ret = fileDataHandler->CleanPureCloudRecord();
683         EXPECT_EQ(E_OK, ret);
684     } catch (...) {
685         EXPECT_TRUE(false);
686         GTEST_LOG_(INFO) << " CleanPureCloudRecord007 ERROR";
687     }
688 
689     GTEST_LOG_(INFO) << "CleanPureCloudRecord007 End";
690 }
691 
692 /**
693  * @tc.name: CleanNotDirtyData002
694  * @tc.desc: Verify the CleanNotDirtyData function
695  * @tc.type: FUNC
696  * @tc.require: issuesI8R3H3
697  */
698 HWTEST_F(FileDataHandlerTest, CleanNotDirtyData002, TestSize.Level1)
699 {
700     GTEST_LOG_(INFO) << "CleanNotDirtyData002 Begin";
701     try {
702         auto rdb = std::make_shared<RdbStoreMock>();
703         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
704         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(nullptr));
705 
706         int32_t ret = fileDataHandler->CleanNotDirtyData();
707         EXPECT_EQ(E_RDB, ret);
708     } catch (...) {
709         EXPECT_TRUE(false);
710         GTEST_LOG_(INFO) << " CleanNotDirtyData002 ERROR";
711     }
712 
713     GTEST_LOG_(INFO) << "CleanNotDirtyData002 End";
714 }
715 
716 /**
717  * @tc.name: CleanNotDirtyData003
718  * @tc.desc: Verify the CleanNotDirtyData function
719  * @tc.type: FUNC
720  * @tc.require: issuesI8R3H3
721  */
722 HWTEST_F(FileDataHandlerTest, CleanNotDirtyData003, TestSize.Level1)
723 {
724     GTEST_LOG_(INFO) << "CleanNotDirtyData003 Begin";
725     try {
726         const int32_t rowCount = 0;
727         auto rdb = std::make_shared<RdbStoreMock>();
728         auto rset = std::make_unique<AbsSharedResultSetMock>();
729         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
730         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(1)));
731         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
732 
733         int32_t ret = fileDataHandler->CleanNotDirtyData();
734         EXPECT_EQ(1, ret);
735     } catch (...) {
736         EXPECT_TRUE(false);
737         GTEST_LOG_(INFO) << " CleanNotDirtyData003 ERROR";
738     }
739 
740     GTEST_LOG_(INFO) << "CleanNotDirtyData003 End";
741 }
742 
743 /**
744  * @tc.name: CleanNotDirtyData004
745  * @tc.desc: Verify the CleanNotDirtyData function
746  * @tc.type: FUNC
747  * @tc.require: issuesI8R3H3
748  */
749 HWTEST_F(FileDataHandlerTest, CleanNotDirtyData004, TestSize.Level1)
750 {
751     GTEST_LOG_(INFO) << "CleanNotDirtyData004 Begin";
752     try {
753         const int32_t rowCount = -1;
754         auto rdb = std::make_shared<RdbStoreMock>();
755         auto rset = std::make_unique<AbsSharedResultSetMock>();
756         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
757         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
758         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
759 
760         int32_t ret = fileDataHandler->CleanNotDirtyData();
761         EXPECT_EQ(E_OK, ret);
762     } catch (...) {
763         EXPECT_TRUE(false);
764         GTEST_LOG_(INFO) << " CleanNotDirtyData004 ERROR";
765     }
766 
767     GTEST_LOG_(INFO) << "CleanNotDirtyData004 End";
768 }
769 
770 /**
771  * @tc.name: CleanNotDirtyData005
772  * @tc.desc: Verify the CleanNotDirtyData function
773  * @tc.type: FUNC
774  * @tc.require: issuesI8R3H3
775  */
776 HWTEST_F(FileDataHandlerTest, CleanNotDirtyData005, TestSize.Level1)
777 {
778     GTEST_LOG_(INFO) << "CleanNotDirtyData005 Begin";
779     try {
780         const int32_t rowCount = 0;
781         auto rdb = std::make_shared<RdbStoreMock>();
782         auto rset = std::make_unique<AbsSharedResultSetMock>();
783         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
784         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
785         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
786         EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
787         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
788 
789         int32_t ret = fileDataHandler->CleanNotDirtyData();
790         EXPECT_EQ(E_OK, ret);
791     } catch (...) {
792         EXPECT_TRUE(false);
793         GTEST_LOG_(INFO) << " CleanNotDirtyData005 ERROR";
794     }
795 
796     GTEST_LOG_(INFO) << "CleanNotDirtyData005 End";
797 }
798 
799 /**
800  * @tc.name: CleanNotDirtyData006
801  * @tc.desc: Verify the CleanNotDirtyData function
802  * @tc.type: FUNC
803  * @tc.require: issuesI8R3H3
804  */
805 HWTEST_F(FileDataHandlerTest, CleanNotDirtyData006, TestSize.Level1)
806 {
807     GTEST_LOG_(INFO) << "CleanNotDirtyData006 Begin";
808     try {
809         const int32_t rowCount = 0;
810         string filePath = "/test/pareantPath/thumbPpath";
811         auto rdb = std::make_shared<RdbStoreMock>();
812         auto rset = std::make_unique<AbsSharedResultSetMock>();
813         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
814         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
815         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0));
816         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
817         EXPECT_CALL(*rset, GetString(_, _))
818             .WillOnce(DoAll(SetArgReferee<1>("1"), Return(1)))
819             .WillOnce(DoAll(SetArgReferee<1>(filePath), Return(1)));
820         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
821 
822         int32_t ret = fileDataHandler->CleanNotDirtyData();
823         EXPECT_EQ(E_INVAL_ARG, ret);
824     } catch (...) {
825         EXPECT_TRUE(false);
826         GTEST_LOG_(INFO) << " CleanNotDirtyData006 ERROR";
827     }
828 
829     GTEST_LOG_(INFO) << "CleanNotDirtyData006 End";
830 }
831 
832 /**
833  * @tc.name: CleanNotDirtyData007
834  * @tc.desc: Verify the CleanNotDirtyData function
835  * @tc.type: FUNC
836  * @tc.require: issuesI8R3H3
837  */
838 HWTEST_F(FileDataHandlerTest, CleanNotDirtyData007, TestSize.Level1)
839 {
840     GTEST_LOG_(INFO) << "CleanNotDirtyData007 Begin";
841     try {
842         const int32_t rowCount = 0;
843         string filePath = "/test/pareantPath/thumbPpath";
844         auto rdb = std::make_shared<RdbStoreMock>();
845         auto rset = std::make_unique<AbsSharedResultSetMock>();
846         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
847         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
848         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1));
849         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
850         EXPECT_CALL(*rset, GetString(_, _))
851             .WillOnce(DoAll(SetArgReferee<1>("1"), Return(1)))
852             .WillOnce(DoAll(SetArgReferee<1>(filePath), Return(0)));
853         EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
854         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
855 
856         int32_t ret = fileDataHandler->CleanNotDirtyData();
857         EXPECT_EQ(E_OK, ret);
858     } catch (...) {
859         EXPECT_TRUE(false);
860         GTEST_LOG_(INFO) << " CleanNotDirtyData007 ERROR";
861     }
862 
863     GTEST_LOG_(INFO) << "CleanNotDirtyData007 End";
864 }
865 
866 /**
867  * @tc.name: OptimizeStorageTest
868  * @tc.desc: Verify the OptimizeStorage function
869  * @tc.type: FUNC
870  * @tc.require: issuesI8R3H3
871  */
872 HWTEST_F(FileDataHandlerTest, OptimizeStorageTest, TestSize.Level1)
873 {
874     GTEST_LOG_(INFO) << "OptimizeStorage Begin";
875     try {
876         const int32_t agingDays = 30;
877         auto rdb = std::make_shared<RdbStoreMock>();
878         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
879         int32_t ret = fileDataHandler-> OptimizeStorage(agingDays);
880         EXPECT_EQ(E_OK, ret);
881     } catch (...) {
882         EXPECT_TRUE(false);
883         GTEST_LOG_(INFO) << "OptimizeStorage ERROR";
884     }
885     GTEST_LOG_(INFO) << "OptimizeStorage End";
886 }
887 
888 /**
889  * @tc.name: GetAgingFileTest001
890  * @tc.desc: Verify the GetAgingFile function
891  * @tc.type: FUNC
892  * @tc.require: issuesI8R3H3
893  */
894 HWTEST_F(FileDataHandlerTest, GetAgingFileTest001, TestSize.Level1)
895 {
896     GTEST_LOG_(INFO) << "GetAgingFile Begin";
897     try {
898         int64_t agingTime = 360;
899         int32_t rowCount = 0;
900 
901         auto rdb = std::make_shared<RdbStoreMock>();
902         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
903 
904         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
905         auto results = fileDataHandler->GetAgingFile(agingTime, rowCount);
906         EXPECT_TRUE(results == nullptr);
907     } catch (...) {
908         EXPECT_TRUE(false);
909         GTEST_LOG_(INFO) << "GetAgingFile ERROR";
910     }
911     GTEST_LOG_(INFO) << "GetAgingFile End";
912 }
913 
914 /**
915  * @tc.name: GetAgingFileTest002
916  * @tc.desc: Verify the GetAgingFile function
917  * @tc.type: FUNC
918  * @tc.require: issuesI8R3H3
919  */
920 HWTEST_F(FileDataHandlerTest, GetAgingFileTest002, TestSize.Level1)
921 {
922     GTEST_LOG_(INFO) << "GetAgingFile Begin";
923     try {
924         int rowCount = 1;
925         int64_t agingTime = 360;
926 
927         auto rdb = std::make_shared<RdbStoreMock>();
928         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
929         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
930 
931         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
932         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
933         auto results = fileDataHandler->GetAgingFile(agingTime, rowCount);
934         EXPECT_TRUE(results != nullptr);
935     } catch (...) {
936         EXPECT_TRUE(false);
937         GTEST_LOG_(INFO) << "GetAgingFile ERROR";
938     }
939     GTEST_LOG_(INFO) << "GetAgingFile End";
940 }
941 
942 /**
943  * @tc.name: GetAgingFileTest003
944  * @tc.desc: Verify the GetAgingFile function
945  * @tc.type: FUNC
946  * @tc.require: issuesI8R3H3
947  */
948 HWTEST_F(FileDataHandlerTest, GetAgingFileTest003, TestSize.Level1)
949 {
950     GTEST_LOG_(INFO) << "GetAgingFile Begin";
951     try {
952         int rowCount = 1;
953         int64_t agingTime = 360;
954 
955         auto rdb = std::make_shared<RdbStoreMock>();
956         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
957         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
958 
959         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(Return(1));
960         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
961         auto results = fileDataHandler->GetAgingFile(agingTime, rowCount);
962         EXPECT_TRUE(results == nullptr);
963     } catch (...) {
964         EXPECT_TRUE(false);
965         GTEST_LOG_(INFO) << "GetAgingFile ERROR";
966     }
967     GTEST_LOG_(INFO) << "GetAgingFile End";
968 }
969 
970 /**
971  * @tc.name: UpdateAgingFileTest001
972  * @tc.desc: Verify the UpdateAgingFile function
973  * @tc.type: FUNC
974  * @tc.require: issuesI8R3H3
975  */
976 HWTEST_F(FileDataHandlerTest, UpdateAgingFileTest001, TestSize.Level1)
977 {
978     GTEST_LOG_(INFO) << "UpdateAgingFile Begin";
979     try {
980         string cloudId = "";
981 
982         auto rdb = std::make_shared<RdbStoreMock>();
983         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
984 
985         EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0));
986         int32_t ret = fileDataHandler->UpdateAgingFile(cloudId);
987         EXPECT_EQ(ret, E_OK);
988     } catch (...) {
989         EXPECT_TRUE(false);
990         GTEST_LOG_(INFO) << "UpdateAgingFile ERROR";
991     }
992     GTEST_LOG_(INFO) << "UpdateAgingFile End";
993 }
994 
995 /**
996  * @tc.name: UpdateAgingFileTest002
997  * @tc.desc: Verify the UpdateAgingFile function
998  * @tc.type: FUNC
999  * @tc.require: issuesI8R3H3
1000  */
1001 HWTEST_F(FileDataHandlerTest, UpdateAgingFileTest002, TestSize.Level1)
1002 {
1003     GTEST_LOG_(INFO) << "UpdateAgingFile Begin";
1004     try {
1005         string cloudId = "";
1006 
1007         auto rdb = std::make_shared<RdbStoreMock>();
1008         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1009 
1010         EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(1));
1011         int32_t ret = fileDataHandler->UpdateAgingFile(cloudId);
1012         EXPECT_EQ(ret, E_RDB);
1013     } catch (...) {
1014         EXPECT_TRUE(false);
1015         GTEST_LOG_(INFO) << "UpdateAgingFile ERROR";
1016     }
1017     GTEST_LOG_(INFO) << "UpdateAgingFile End";
1018 }
1019 
1020 /**
1021  * @tc.name: FileAgingDeleteTest001
1022  * @tc.desc: Verify the FileAgingDelete function
1023  * @tc.type: FUNC
1024  * @tc.require: issuesI8R3H3
1025  */
1026 HWTEST_F(FileDataHandlerTest, FileAgingDeleteTest001, TestSize.Level1)
1027 {
1028     GTEST_LOG_(INFO) << "FileAgingDelete Begin";
1029     try {
1030         int64_t agingTime = 360;
1031         int64_t deleteSize = 1000;
1032 
1033         auto rdb = std::make_shared<RdbStoreMock>();
1034         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1035 
1036         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
1037         int32_t ret = fileDataHandler->FileAgingDelete(agingTime, deleteSize);
1038         EXPECT_EQ(ret, E_RDB);
1039     } catch (...) {
1040         EXPECT_TRUE(false);
1041         GTEST_LOG_(INFO) << "FileAgingDelete ERROR";
1042     }
1043     GTEST_LOG_(INFO) << "FileAgingDelete End";
1044 }
1045 
1046 /**
1047  * @tc.name: FileAgingDeleteTest002
1048  * @tc.desc: Verify the FileAgingDelete function
1049  * @tc.type: FUNC
1050  * @tc.require: issuesI8R3H3
1051  */
1052 HWTEST_F(FileDataHandlerTest, FileAgingDeleteTest002, TestSize.Level1)
1053 {
1054     GTEST_LOG_(INFO) << "FileAgingDelete Begin";
1055     try {
1056         const int32_t rowCount = 1;
1057         int64_t agingTime = 360;
1058         int64_t deleteSize = 1000;
1059 
1060         auto rdb = std::make_shared<RdbStoreMock>();
1061         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1062         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1063 
1064         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
1065         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
1066         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1067         int32_t ret = fileDataHandler->FileAgingDelete(agingTime, deleteSize);
1068         EXPECT_EQ(ret, E_OK);
1069     } catch (...) {
1070         EXPECT_TRUE(false);
1071         GTEST_LOG_(INFO) << "FileAgingDelete ERROR";
1072     }
1073     GTEST_LOG_(INFO) << "FileAgingDelete End";
1074 }
1075 
1076 /**
1077  * @tc.name: FileAgingDeleteTest003
1078  * @tc.desc: Verify the FileAgingDelete function
1079  * @tc.type: FUNC
1080  * @tc.require: issuesI8R3H3
1081  */
1082 HWTEST_F(FileDataHandlerTest, FileAgingDeleteTest003, TestSize.Level1)
1083 {
1084     GTEST_LOG_(INFO) << "FileAgingDelete Begin";
1085     try {
1086         const int32_t rowCount = 3;
1087         int64_t agingTime = 360;
1088         int64_t deleteSize = 1000;
1089 
1090         auto rdb = std::make_shared<RdbStoreMock>();
1091         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1092         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1093 
1094         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
1095         EXPECT_CALL(*rset, GoToNextRow())
1096             .Times(rowCount)
1097             .WillOnce(Return(0))
1098             .WillOnce(Return(0))
1099             .WillRepeatedly(Return(1));
1100         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1101         EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(1));
1102         EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0));
1103         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1104         int32_t ret = fileDataHandler->FileAgingDelete(agingTime, deleteSize);
1105         EXPECT_EQ(ret, E_OK);
1106     } catch (...) {
1107         EXPECT_TRUE(false);
1108         GTEST_LOG_(INFO) << "FileAgingDelete ERROR";
1109     }
1110     GTEST_LOG_(INFO) << "FileAgingDelete End";
1111 }
1112 
1113 /**
1114  * @tc.name: FileAgingDeleteTest004
1115  * @tc.desc: Verify the FileAgingDelete function
1116  * @tc.type: FUNC
1117  * @tc.require: issuesI8R3H3
1118  */
1119 HWTEST_F(FileDataHandlerTest, FileAgingDeleteTest004, TestSize.Level1)
1120 {
1121     GTEST_LOG_(INFO) << "FileAgingDelete Begin";
1122     try {
1123         const int32_t rowCount = 3;
1124         int64_t agingTime = 360;
1125         int64_t deleteSize = 1000;
1126 
1127         auto rdb = std::make_shared<RdbStoreMock>();
1128         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1129         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1130 
1131         EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
1132         EXPECT_CALL(*rset, GoToNextRow())
1133             .Times(rowCount)
1134             .WillOnce(Return(0))
1135             .WillOnce(Return(0))
1136             .WillRepeatedly(Return(1));
1137         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1138         EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
1139         EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(1));
1140         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1141         int32_t ret = fileDataHandler->FileAgingDelete(agingTime, deleteSize);
1142         EXPECT_EQ(ret, E_OK);
1143     } catch (...) {
1144         EXPECT_TRUE(false);
1145         GTEST_LOG_(INFO) << "FileAgingDelete ERROR";
1146     }
1147     GTEST_LOG_(INFO) << "FileAgingDelete End";
1148 }
1149 
1150 /**
1151  * @tc.name: GetThumbToDownloadTest001
1152  * @tc.desc: Verify the GetThumbToDownload function
1153  * @tc.type: FUNC
1154  * @tc.require: issuesI8R3H3
1155  */
1156 HWTEST_F(FileDataHandlerTest, GetThumbToDownloadTest001, TestSize.Level1)
1157 {
1158     GTEST_LOG_(INFO) << "GetThumbToDownload Begin";
1159     try {
1160         std::vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
1161         auto rdb = std::make_shared<RdbStoreMock>();
1162         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1163 
1164         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
1165         int32_t ret = fileDataHandler->GetThumbToDownload(outAssetsToDownload);
1166         EXPECT_EQ(ret, E_RDB);
1167     } catch (...) {
1168         EXPECT_TRUE(false);
1169         GTEST_LOG_(INFO) << "GetThumbToDownload ERROR";
1170     }
1171     GTEST_LOG_(INFO) << "GetThumbToDownload End";
1172 }
1173 
1174 /**
1175  * @tc.name: GetThumbToDownloadTest002
1176  * @tc.desc: Verify the GetThumbToDownload function
1177  * @tc.type: FUNC
1178  * @tc.require: issuesI8R3H3
1179  */
1180 HWTEST_F(FileDataHandlerTest, GetThumbToDownloadTest002, TestSize.Level1)
1181 {
1182     GTEST_LOG_(INFO) << "GetThumbToDownload Begin";
1183     try {
1184         std::vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
1185         auto rdb = std::make_shared<RdbStoreMock>();
1186         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1187         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1188 
1189         EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
1190         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1191         int32_t ret = fileDataHandler->GetThumbToDownload(outAssetsToDownload);
1192         EXPECT_EQ(ret, E_OK);
1193     } catch (...) {
1194         EXPECT_TRUE(false);
1195         GTEST_LOG_(INFO) << "GetThumbToDownload ERROR";
1196     }
1197     GTEST_LOG_(INFO) << "GetThumbToDownload End";
1198 }
1199 
1200 /**
1201  * @tc.name: GetThumbToDownloadTest003
1202  * @tc.desc: Verify the GetThumbToDownload function
1203  * @tc.type: FUNC
1204  * @tc.require: issuesI8R3H3
1205  */
1206 HWTEST_F(FileDataHandlerTest, GetThumbToDownloadTest003, TestSize.Level1)
1207 {
1208     GTEST_LOG_(INFO) << "GetThumbToDownload Begin";
1209     try {
1210         const int32_t rowCount = 3;
1211         std::vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
1212         auto rdb = std::make_shared<RdbStoreMock>();
1213         auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1214         std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1215 
1216         EXPECT_CALL(*rset, GoToNextRow())
1217             .Times(rowCount)
1218             .WillOnce(Return(0))
1219             .WillOnce(Return(0))
1220             .WillRepeatedly(Return(1));
1221         EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1222         EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(0));
1223         EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1224         int32_t ret = fileDataHandler->GetThumbToDownload(outAssetsToDownload);
1225         EXPECT_EQ(ret, E_OK);
1226     } catch (...) {
1227         EXPECT_TRUE(false);
1228         GTEST_LOG_(INFO) << "GetThumbToDownload ERROR";
1229     }
1230     GTEST_LOG_(INFO) << "GetThumbToDownload End";
1231 }