1 /*
2 * Copyright (C) 2025 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 "accesstoken_kit_mock.h"
20 #include "environment_core.h"
21 #include "ipc_skeleton_mock.h"
22 #include "parameter_mock.h"
23 #include "securec.h"
24
25 namespace OHOS::FileManagement::ModuleFileIO::Test {
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace std;
29
30 class EnvironmentCoreTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36 static inline shared_ptr<Backup::AccessTokenKitMock> accessToken = nullptr;
37 static inline std::shared_ptr<AppFileService::ParamMoc> paramMoc = nullptr;
38 static inline shared_ptr<Backup::IPCSkeletonMock> skeleton = nullptr;
39 };
40
SetUpTestCase(void)41 void EnvironmentCoreTest::SetUpTestCase(void)
42 {
43 GTEST_LOG_(INFO) << "SetUpTestCase";
44 accessToken = std::make_shared<Backup::AccessTokenKitMock>();
45 Backup::BAccessTokenKit::token = accessToken;
46 paramMoc = std::make_shared<AppFileService::ParamMoc>();
47 AppFileService::ParamMoc::paramMoc = paramMoc;
48 skeleton = make_shared<Backup::IPCSkeletonMock>();
49 Backup::IPCSkeletonMock::skeleton = skeleton;
50 }
51
TearDownTestCase(void)52 void EnvironmentCoreTest::TearDownTestCase(void)
53 {
54 GTEST_LOG_(INFO) << "TearDownTestCase";
55 Backup::BAccessTokenKit::token = nullptr;
56 accessToken = nullptr;
57 AppFileService::IParamMoc::paramMoc = nullptr;
58 paramMoc = nullptr;
59 Backup::IPCSkeletonMock::skeleton = nullptr;
60 skeleton = nullptr;
61 }
62
SetUp(void)63 void EnvironmentCoreTest::SetUp(void)
64 {
65 GTEST_LOG_(INFO) << "SetUp";
66 }
67
TearDown(void)68 void EnvironmentCoreTest::TearDown(void)
69 {
70 GTEST_LOG_(INFO) << "TearDown";
71 }
72
73 /**
74 * @tc.name: EnvironmentCoreTest_DoGetStorageDataDir_001
75 * @tc.desc: Test function of DoGetStorageDataDir interface for FALSE tokenID error.
76 * @tc.size: MEDIUM
77 * @tc.type: FUNC
78 * @tc.level Level 1
79 */
80 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetStorageDataDir_001, testing::ext::TestSize.Level1)
81 {
82 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetStorageDataDir_001";
83
84 EXPECT_CALL(*accessToken, IsSystemAppByFullTokenID(_)).WillOnce(Return(false));
85
86 auto res = ModuleEnvironment::DoGetStorageDataDir();
87
88 EXPECT_FALSE(res.IsSuccess());
89
90 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetStorageDataDir_001";
91 }
92
93 /**
94 * @tc.name: EnvironmentCoreTest_DoGetStorageDataDir_002
95 * @tc.desc: Test function of DoGetStorageDataDir interface for success.
96 * @tc.size: MEDIUM
97 * @tc.type: FUNC
98 * @tc.level Level 1
99 */
100 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetStorageDataDir_002, testing::ext::TestSize.Level1)
101 {
102 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetStorageDataDir_002";
103
104 EXPECT_CALL(*accessToken, IsSystemAppByFullTokenID(_)).WillOnce(Return(true));
105
106 auto res = ModuleEnvironment::DoGetStorageDataDir();
107
108 EXPECT_TRUE(res.IsSuccess());
109
110 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetStorageDataDir_002";
111 }
112
113 /**
114 * @tc.name: EnvironmentCoreTest_DoGetUserDataDir_001
115 * @tc.desc: Test function of DoGetUserDataDir interface for FALSE.
116 * @tc.size: MEDIUM
117 * @tc.type: FUNC
118 * @tc.level Level 1
119 */
120 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDataDir_001, testing::ext::TestSize.Level1)
121 {
122 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDataDir_001";
123
124 EXPECT_CALL(*accessToken, IsSystemAppByFullTokenID(_)).WillOnce(Return(false));
125
126 auto res = ModuleEnvironment::DoGetUserDataDir();
127
128 EXPECT_FALSE(res.IsSuccess());
129
130 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDataDir_001";
131 }
132
133 /**
134 * @tc.name: EnvironmentCoreTest_DoGetUserDataDir_002
135 * @tc.desc: Test function of DoGetUserDataDir interface for success.
136 * @tc.size: MEDIUM
137 * @tc.type: FUNC
138 * @tc.level Level 1
139 */
140 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDataDir_002, testing::ext::TestSize.Level1)
141 {
142 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDataDir_002";
143
144 EXPECT_CALL(*accessToken, IsSystemAppByFullTokenID(_)).WillOnce(Return(true));
145
146 auto res = ModuleEnvironment::DoGetUserDataDir();
147
148 EXPECT_TRUE(res.IsSuccess());
149
150 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDataDir_002";
151 }
152
153 /**
154 * @tc.name: EnvironmentCoreTest_DoGetUserDownloadDir_001
155 * @tc.desc: Test function of DoGetUserDownloadDir interface for success.
156 * @tc.size: MEDIUM
157 * @tc.type: FUNC
158 * @tc.level Level 1
159 */
160 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDownloadDir_001, testing::ext::TestSize.Level1)
161 {
162 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDownloadDir_001";
163
164 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0102(const char *, const char *, char *value, uint32_t) 165 .WillRepeatedly(Invoke([&](const char *, const char *, char *value, uint32_t) {
166 strcpy_s(value, 5, "true");
167 uint32_t successValue = 1;
168 return successValue;
169 }));
170 EXPECT_CALL(*skeleton, GetOsAccountShortName(_)).WillRepeatedly(Return(ERR_OK));
171
172 auto res = ModuleEnvironment::DoGetUserDownloadDir();
173
174 EXPECT_TRUE(res.IsSuccess());
175
176 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDownloadDir_001";
177 }
178
179 /**
180 * @tc.name: EnvironmentCoreTest_DoGetUserDownloadDir_002
181 * @tc.desc: Test function of DoGetUserDownloadDir interface for FALSE.
182 * @tc.size: MEDIUM
183 * @tc.type: FUNC
184 * @tc.level Level 1
185 */
186 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDownloadDir_002, testing::ext::TestSize.Level1)
187 {
188 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDownloadDir_002";
189
190 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _)).WillOnce(Return(-1));
191
192 auto res = ModuleEnvironment::DoGetUserDownloadDir();
193
194 EXPECT_FALSE(res.IsSuccess());
195
196 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDownloadDir_002";
197 }
198
199 /**
200 * @tc.name: EnvironmentCoreTest_DoGetUserDownloadDir_003
201 * @tc.desc: Test function of DoGetUserDownloadDir interface for FALSE.
202 * @tc.size: MEDIUM
203 * @tc.type: FUNC
204 * @tc.level Level 1
205 */
206 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDownloadDir_003, testing::ext::TestSize.Level1)
207 {
208 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDownloadDir_003";
209
210 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0202(const char *, const char *, char *value, uint32_t) 211 .WillRepeatedly(Invoke([&](const char *, const char *, char *value, uint32_t) {
212 strcpy_s(value, 5, "true");
213 return 1;
214 }));
215 EXPECT_CALL(*skeleton, GetOsAccountShortName(_)).WillRepeatedly(Return(1));
216
217 auto res = ModuleEnvironment::DoGetUserDownloadDir();
218
219 EXPECT_FALSE(res.IsSuccess());
220
221 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDownloadDir_003";
222 }
223
224 /**
225 * @tc.name: EnvironmentCoreTest_DoGetUserDesktopDir_001
226 * @tc.desc: Test function of DoGetUserDesktopDir interface for success.
227 * @tc.size: MEDIUM
228 * @tc.type: FUNC
229 * @tc.level Level 1
230 */
231 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDesktopDir_001, testing::ext::TestSize.Level1)
232 {
233 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDesktopDir_001";
234
235 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0302(const char *key, const char *def, char *value, uint32_t len) 236 .WillOnce(Invoke([&](const char *key, const char *def, char *value, uint32_t len) {
237 strcpy_s(value, 5, "true");
238 return 1;
239 }));
240
241 auto res = ModuleEnvironment::DoGetUserDesktopDir();
242
243 EXPECT_TRUE(res.IsSuccess());
244
245 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDesktopDir_001";
246 }
247
248 /**
249 * @tc.name: EnvironmentCoreTest_DoGetUserDesktopDir_002
250 * @tc.desc: Test function of DoGetUserDesktopDir interface for FALSE.
251 * @tc.size: MEDIUM
252 * @tc.type: FUNC
253 * @tc.level Level 1
254 */
255 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDesktopDir_002, testing::ext::TestSize.Level1)
256 {
257 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDesktopDir_002";
258
259 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0402(const char *key, const char *def, char *value, uint32_t len) 260 .WillOnce(Invoke([&](const char *key, const char *def, char *value, uint32_t len) {
261 strcpy_s(value, 5, "true");
262 return -1;
263 }));
264
265 auto res = ModuleEnvironment::DoGetUserDesktopDir();
266
267 EXPECT_FALSE(res.IsSuccess());
268
269 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDesktopDir_002";
270 }
271
272 /**
273 * @tc.name: EnvironmentCoreTest_DoGetUserDesktopDir_003
274 * @tc.desc: Test function of DoGetUserDesktopDir interface for success.
275 * @tc.size: MEDIUM
276 * @tc.type: FUNC
277 * @tc.level Level 1
278 */
279 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDesktopDir_003, testing::ext::TestSize.Level1)
280 {
281 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDesktopDir_003";
282
283 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0502(const char *, const char *, char *value, uint32_t) 284 .WillOnce(Invoke([&](const char *, const char *, char *value, uint32_t) {
285 strcpy_s(value, 5, "true");
286 return 1;
287 }));
288 EXPECT_CALL(*skeleton, GetOsAccountShortName(_)).WillRepeatedly(Return(ERR_OK));
289
290 auto res = ModuleEnvironment::DoGetUserDesktopDir();
291
292 EXPECT_FALSE(res.IsSuccess());
293
294 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDesktopDir_003";
295 }
296
297 /**
298 * @tc.name: EnvironmentCoreTest_DoGetUserDocumentDir_001
299 * @tc.desc: Test function of DoGetUserDocumentDir interface for success.
300 * @tc.size: MEDIUM
301 * @tc.type: FUNC
302 * @tc.level Level 1
303 */
304 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDocumentDir_001, testing::ext::TestSize.Level1)
305 {
306 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDocumentDir_001";
307
308 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0602(const char *key, const char *def, char *value, uint32_t len) 309 .WillOnce(Invoke([&](const char *key, const char *def, char *value, uint32_t len) {
310 strcpy_s(value, 5, "true");
311 return 1;
312 }));
313
314 auto res = ModuleEnvironment::DoGetUserDocumentDir();
315
316 EXPECT_TRUE(res.IsSuccess());
317
318 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDocumentDir_001";
319 }
320
321 /**
322 * @tc.name: EnvironmentCoreTest_DoGetUserDocumentDir_002
323 * @tc.desc: Test function of DoGetUserDocumentDir interface for FALSE.
324 * @tc.size: MEDIUM
325 * @tc.type: FUNC
326 * @tc.level Level 1
327 */
328 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDocumentDir_002, testing::ext::TestSize.Level1)
329 {
330 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDocumentDir_002";
331
332 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0702(const char *key, const char *def, char *value, uint32_t len) 333 .WillOnce(Invoke([&](const char *key, const char *def, char *value, uint32_t len) {
334 strcpy_s(value, 5, "true");
335 return -1;
336 }));
337
338 auto res = ModuleEnvironment::DoGetUserDocumentDir();
339
340 EXPECT_FALSE(res.IsSuccess());
341
342 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDocumentDir_002";
343 }
344
345 /**
346 * @tc.name: EnvironmentCoreTest_DoGetUserDocumentDir_003
347 * @tc.desc: Test function of DoGetUserDocumentDir interface for FALSE.
348 * @tc.size: MEDIUM
349 * @tc.type: FUNC
350 * @tc.level Level 1
351 */
352 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserDocumentDir_003, testing::ext::TestSize.Level1)
353 {
354 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserDocumentDir_003";
355
356 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0802(const char *, const char *, char *value, uint32_t) 357 .WillOnce(Invoke([&](const char *, const char *, char *value, uint32_t) {
358 strcpy_s(value, 5, "true");
359 return 1;
360 }));
361
362 auto res = ModuleEnvironment::DoGetUserDocumentDir();
363
364 EXPECT_FALSE(res.IsSuccess());
365
366 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserDocumentDir_003";
367 }
368
369 /**
370 * @tc.name: EnvironmentCoreTest_DoGetExternalStorageDir_001
371 * @tc.desc: Test function of DoGetExternalStorageDir interface for FALSE.
372 * @tc.size: MEDIUM
373 * @tc.type: FUNC
374 * @tc.level Level 1
375 */
376 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetExternalStorageDir_001, testing::ext::TestSize.Level1)
377 {
378 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetExternalStorageDir_001";
379
380 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0902(const char *key, const char *def, char *value, uint32_t len) 381 .WillOnce(Invoke([&](const char *key, const char *def, char *value, uint32_t len) {
382 strcpy_s(value, 5, "true");
383 return 1;
384 }));
385 EXPECT_CALL(*accessToken, IsSystemAppByFullTokenID(_)).WillOnce(Return(false));
386
387 auto res = ModuleEnvironment::DoGetExternalStorageDir();
388
389 EXPECT_FALSE(res.IsSuccess());
390
391 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetExternalStorageDir_001";
392 }
393
394 /**
395 * @tc.name: EnvironmentCoreTest_DoGetExternalStorageDir_002
396 * @tc.desc: Test function of DoGetExternalStorageDir interface for FALSE.
397 * @tc.size: MEDIUM
398 * @tc.type: FUNC
399 * @tc.level Level 1
400 */
401 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetExternalStorageDir_002, testing::ext::TestSize.Level1)
402 {
403 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetExternalStorageDir_002";
404
405 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0a02(const char *key, const char *def, char *value, uint32_t len) 406 .WillOnce(Invoke([&](const char *key, const char *def, char *value, uint32_t len) {
407 strcpy_s(value, 5, "true");
408 return 1;
409 }));
410 EXPECT_CALL(*accessToken, IsSystemAppByFullTokenID(_)).WillOnce(Return(true));
411 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
412 EXPECT_CALL(*accessToken, VerifyAccessToken(_, _)).WillOnce(Return(1));
413
414 auto res = ModuleEnvironment::DoGetExternalStorageDir();
415
416 EXPECT_FALSE(res.IsSuccess());
417
418 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetExternalStorageDir_002";
419 }
420
421 /**
422 * @tc.name: EnvironmentCoreTest_DoGetExternalStorageDir_003
423 * @tc.desc: Test function of DoGetExternalStorageDir interface for success.
424 * @tc.size: MEDIUM
425 * @tc.type: FUNC
426 * @tc.level Level 1
427 */
428 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetExternalStorageDir_003, testing::ext::TestSize.Level1)
429 {
430 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetExternalStorageDir_003";
431
432 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0b02(const char *key, const char *def, char *value, uint32_t len) 433 .WillOnce(Invoke([&](const char *key, const char *def, char *value, uint32_t len) {
434 strcpy_s(value, 5, "true");
435 return 1;
436 }));
437 EXPECT_CALL(*accessToken, IsSystemAppByFullTokenID(_)).WillOnce(Return(true));
438 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
439 EXPECT_CALL(*accessToken, VerifyAccessToken(_, _))
440 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
441
442 auto res = ModuleEnvironment::DoGetExternalStorageDir();
443
444 EXPECT_TRUE(res.IsSuccess());
445
446 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetExternalStorageDir_003";
447 }
448
449 /**
450 * @tc.name: EnvironmentCoreTest_DoGetExternalStorageDir_004
451 * @tc.desc: Test function of DoGetExternalStorageDir interface for FALSE.
452 * @tc.size: MEDIUM
453 * @tc.type: FUNC
454 * @tc.level Level 1
455 */
456 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetExternalStorageDir_004, testing::ext::TestSize.Level1)
457 {
458 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetExternalStorageDir_004";
459
460 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0c02(const char *key, const char *def, char *value, uint32_t len) 461 .WillOnce(Invoke([&](const char *key, const char *def, char *value, uint32_t len) {
462 strcpy_s(value, 5, "true");
463 return 1;
464 }));
465 EXPECT_CALL(*accessToken, IsSystemAppByFullTokenID(_)).WillOnce(Return(false));
466
467 auto res = ModuleEnvironment::DoGetExternalStorageDir();
468
469 EXPECT_FALSE(res.IsSuccess());
470
471 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetExternalStorageDir_004";
472 }
473
474 /**
475 * @tc.name: EnvironmentCoreTest_DoGetUserHomeDir_001
476 * @tc.desc: Test function of DoGetUserHomeDir interface for FALSE.
477 * @tc.size: MEDIUM
478 * @tc.type: FUNC
479 * @tc.level Level 1
480 */
481 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserHomeDir_001, testing::ext::TestSize.Level1)
482 {
483 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserHomeDir_001";
484
485 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _)).WillOnce(Return(1));
486
487 auto res = ModuleEnvironment::DoGetUserHomeDir();
488
489 EXPECT_FALSE(res.IsSuccess());
490
491 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserHomeDir_001";
492 }
493
494 /**
495 * @tc.name: EnvironmentCoreTest_DoGetUserHomeDir_002
496 * @tc.desc: Test function of DoGetUserHomeDir interface for success.
497 * @tc.size: MEDIUM
498 * @tc.type: FUNC
499 * @tc.level Level 1
500 */
501 HWTEST_F(EnvironmentCoreTest, EnvironmentCoreTest_DoGetUserHomeDir_002, testing::ext::TestSize.Level1)
502 {
503 GTEST_LOG_(INFO) << "EnvironmentCoreTest-begin EnvironmentCoreTest_DoGetUserHomeDir_002";
504
505 EXPECT_CALL(*paramMoc, GetParameter(_, _, _, _))
__anon48da079b0d02(const char *key, const char *def, char *value, uint32_t len) 506 .WillOnce(Invoke([&](const char *key, const char *def, char *value, uint32_t len) {
507 strcpy_s(value, 5, "true");
508 return 1;
509 }));
510 EXPECT_CALL(*accessToken, IsSystemAppByFullTokenID(_)).WillOnce(Return(true));
511 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
512 EXPECT_CALL(*accessToken, VerifyAccessToken(_, _))
513 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
514
515 auto res = ModuleEnvironment::DoGetUserHomeDir();
516
517 EXPECT_TRUE(res.IsSuccess());
518
519 GTEST_LOG_(INFO) << "EnvironmentCoreTest-end EnvironmentCoreTest_DoGetUserHomeDir_002";
520 }
521
522 } // namespace OHOS::FileManagement::ModuleFileIO::Test