1 /*
2  * Copyright (c) 2024 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 #include <memory>
19 #include <vector>
20 
21 #include "assistant.h"
22 #include "file_access_extension_info.h"
23 #include "file_access_framework_errno.h"
24 #include "file_access_service_proxy.h"
25 #include "file_access_service_mock.h"
26 #include "if_system_ability_manager_mock.h"
27 #include "iservice_registry.h"
28 
OnRemoteRequest(unsigned int,OHOS::MessageParcel &,OHOS::MessageParcel &,OHOS::MessageOption &)29 int32_t OHOS::SystemAbilityLoadCallbackStub::OnRemoteRequest(unsigned int, OHOS::MessageParcel&, OHOS::MessageParcel&,
30     OHOS::MessageOption&)
31 {
32     return 0;
33 }
34 
35 namespace OHOS::FileAccessFwk {
36 using namespace std;
37 using namespace testing;
38 using namespace testing::ext;
39 
FileAccessServiceStub()40 FileAccessServiceStub::FileAccessServiceStub() {}
41 
~FileAccessServiceStub()42 FileAccessServiceStub::~FileAccessServiceStub() {}
43 
OnRemoteRequest(unsigned int,OHOS::MessageParcel &,OHOS::MessageParcel &,OHOS::MessageOption &)44 int32_t FileAccessServiceStub::OnRemoteRequest(unsigned int, OHOS::MessageParcel&, OHOS::MessageParcel&,
45     OHOS::MessageOption&)
46 {
47     return 0;
48 }
49 
50 class IFileAccessObserverMock : public IFileAccessObserver {
51 public:
52     MOCK_METHOD1(OnChange, void(NotifyMessage &notifyMessage));
53     MOCK_METHOD0(AsObject, sptr<IRemoteObject>());
54 };
55 
56 class FileAccessServiceProxyTest : public testing::Test {
57 public:
SetUpTestCase(void)58     static void SetUpTestCase(void)
59     {
60         Assistant::ins_ = insMoc;
61         SystemAbilityManagerClient::GetInstance().systemAbilityManager_ = sptr<ISystemAbilityManager>(samgr.get());
62     }
TearDownTestCase()63     static void TearDownTestCase()
64     {
65         insMoc = nullptr;
66         samgr = nullptr;
67         impl = nullptr;
68         Assistant::ins_ = nullptr;
69         SystemAbilityManagerClient::GetInstance().systemAbilityManager_ = nullptr;
70     }
SetUp()71     void SetUp() {}
TearDown()72     void TearDown() {}
73 public:
74     static inline shared_ptr<AssistantMock> insMoc = make_shared<AssistantMock>();
75     static inline sptr<FileAccessServiceMock> impl = sptr<FileAccessServiceMock>(new FileAccessServiceMock());
76     static inline shared_ptr<ISystemAbilityManagerMock> samgr = make_shared<ISystemAbilityManagerMock>();
77 };
78 
79 /**
80  * @tc.number: user_file_service_file_access_service_proxy_GetInstance_0001
81  * @tc.name: file_access_service_proxy_GetInstance_0001
82  * @tc.desc: Test function of GetInstance interface for ERROR because samgr is nullptr.
83  * @tc.size: MEDIUM
84  * @tc.type: FUNC
85  * @tc.level Level 3
86  * @tc.require: issuesI8Y05B
87  */
88 HWTEST_F(FileAccessServiceProxyTest, file_access_service_proxy_GetInstance_0001, testing::ext::TestSize.Level1)
89 {
90     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-begin file_access_service_proxy_GetInstance_0001";
91     try {
92         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(false));
93 
94         shared_ptr<FileAccessServiceProxy> proxy = make_shared<FileAccessServiceProxy>(nullptr);
95         proxy->serviceProxy_ = nullptr;
96         auto result = proxy->GetInstance();
97         EXPECT_TRUE(result == nullptr) << "GetInstance Faild";
98     } catch (...) {
99         GTEST_LOG_(ERROR) << "FileAccessServiceProxyTest occurs an exception.";
100     }
101     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-end file_access_service_proxy_GetInstance_0001";
102 }
103 
104 /**
105  * @tc.number: user_file_service_file_access_service_proxy_GetInstance_0002
106  * @tc.name: file_access_service_proxy_GetInstance_0002
107  * @tc.desc: Test function of GetInstance interface for ERROR because samgr->LoadSystemAbility doesn't return ERR_OK.
108  * @tc.size: MEDIUM
109  * @tc.type: FUNC
110  * @tc.level Level 3
111  * @tc.require: issuesI8Y05B
112  */
113 HWTEST_F(FileAccessServiceProxyTest, file_access_service_proxy_GetInstance_0002, testing::ext::TestSize.Level1)
114 {
115     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-begin file_access_service_proxy_GetInstance_0002";
116     try {
117         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true));
118         EXPECT_CALL(*samgr, LoadSystemAbility(An<int32_t>(), An<const sptr<ISystemAbilityLoadCallback>&>()))
119             .WillOnce(Return(E_PERMISSION));
120 
121         shared_ptr<FileAccessServiceProxy> proxy = make_shared<FileAccessServiceProxy>(nullptr);
122         proxy->serviceProxy_ = nullptr;
123         auto result = proxy->GetInstance();
124         EXPECT_TRUE(result == nullptr);
125     } catch (...) {
126         GTEST_LOG_(ERROR) << "FileAccessServiceProxyTest occurs an exception.";
127     }
128     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-end file_access_service_proxy_GetInstance_0002";
129 }
130 
131 /**
132  * @tc.number: user_file_service_file_access_service_proxy_GetInstance_0003
133  * @tc.name: file_access_service_proxy_GetInstance_0003
134  * @tc.desc: Test function of GetInstance interface for ERROR because wait_for timeout.
135  * @tc.size: MEDIUM
136  * @tc.type: FUNC
137  * @tc.level Level 3
138  * @tc.require: issuesI8Y05B
139  */
140 HWTEST_F(FileAccessServiceProxyTest, file_access_service_proxy_GetInstance_0003, testing::ext::TestSize.Level1)
141 {
142     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-begin file_access_service_proxy_GetInstance_0003";
143     try {
144         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true));
145         EXPECT_CALL(*samgr, LoadSystemAbility(An<int32_t>(), An<const sptr<ISystemAbilityLoadCallback>&>()))
146             .WillOnce(Return(ERR_OK));
147 
148         shared_ptr<FileAccessServiceProxy> proxy = make_shared<FileAccessServiceProxy>(nullptr);
149         proxy->serviceProxy_ = nullptr;
150         auto result = proxy->GetInstance();
151         EXPECT_TRUE(result == nullptr);
152     } catch (...) {
153         GTEST_LOG_(ERROR) << "FileAccessServiceProxyTest occurs an exception.";
154     }
155     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-end file_access_service_proxy_GetInstance_0003";
156 }
157 
158 /**
159  * @tc.number: user_file_service_file_access_service_proxy_OnChange_0000
160  * @tc.name: file_access_service_proxy_OnChange_0000
161  * @tc.desc: Test function of OnChange interface for ERROR.
162  * @tc.size: MEDIUM
163  * @tc.type: FUNC
164  * @tc.level Level 3
165  * @tc.require: issuesI8Y05B
166  */
167 HWTEST_F(FileAccessServiceProxyTest, file_access_service_proxy_OnChange_0000, testing::ext::TestSize.Level1)
168 {
169     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-begin file_access_service_proxy_OnChange_0000";
170     try {
171         shared_ptr<FileAccessServiceProxy> proxy = make_shared<FileAccessServiceProxy>(impl);
172 
173         Uri uri("");
174         NotifyType notifyType = NotifyType::NOTIFY_ADD;
175         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(false));
176         auto result = proxy->OnChange(uri, notifyType);
177         EXPECT_EQ(result, E_IPCS);
178         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(false));
179         result = proxy->OnChange(uri, notifyType);
180         EXPECT_EQ(result, E_IPCS);
181         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(false));
182         result = proxy->OnChange(uri, notifyType);
183         EXPECT_EQ(result, E_IPCS);
184         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true));
185         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(E_URIS));
186         result = proxy->OnChange(uri, notifyType);
187         EXPECT_EQ(result, E_URIS);
188         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
189             .WillOnce(Return(false));
190         EXPECT_CALL(*insMoc, Int()).WillOnce(Return(ERR_OK));
191         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
192         result = proxy->OnChange(uri, notifyType);
193         EXPECT_EQ(result, ERR_OK);
194         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
195             .WillOnce(Return(true));
196         EXPECT_CALL(*insMoc, Int()).WillOnce(Return(E_IPCS));
197         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
198         result = proxy->OnChange(uri, notifyType);
199         EXPECT_EQ(result, E_IPCS);
200     } catch (...) {
201         GTEST_LOG_(ERROR) << "FileAccessServiceProxyTest occurs an exception.";
202     }
203     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-end file_access_service_proxy_OnChange_0000";
204 }
205 
206 /**
207  * @tc.number: user_file_service_file_access_service_proxy_RegisterNotify_0000
208  * @tc.name: file_access_service_proxy_RegisterNotify_0000
209  * @tc.desc: Test function of RegisterNotify interface for ERROR.
210  * @tc.size: MEDIUM
211  * @tc.type: FUNC
212  * @tc.level Level 3
213  * @tc.require: issuesI8Y05B
214  */
215 HWTEST_F(FileAccessServiceProxyTest, file_access_service_proxy_RegisterNotify_0000, testing::ext::TestSize.Level1)
216 {
217     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-begin file_access_service_proxy_RegisterNotify_0000";
218     try {
219         shared_ptr<FileAccessServiceProxy> proxy = make_shared<FileAccessServiceProxy>(impl);
220 
221         Uri uri("");
222         bool notifyForDescendants = false;
223         shared_ptr<ConnectExtensionInfo> info = nullptr;
224         sptr<IFileAccessObserverMock> observer = sptr<IFileAccessObserverMock>(new IFileAccessObserverMock());
225         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(false));
226         auto result = proxy->RegisterNotify(uri, notifyForDescendants, observer, info);
227         EXPECT_EQ(result, E_IPCS);
228         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(false));
229         result = proxy->RegisterNotify(uri, notifyForDescendants, observer, info);
230         EXPECT_EQ(result, E_IPCS);
231         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(false));
232         EXPECT_CALL(*observer, AsObject()).WillOnce(Return(nullptr));
233         result = proxy->RegisterNotify(uri, notifyForDescendants, observer, info);
234         EXPECT_EQ(result, E_IPCS);
235         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
236             .WillOnce(Return(false));
237         EXPECT_CALL(*observer, AsObject()).WillOnce(Return(nullptr));
238         result = proxy->RegisterNotify(uri, notifyForDescendants, observer, info);
239         EXPECT_EQ(result, E_IPCS);
240         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
241             .WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true));
242         EXPECT_CALL(*observer, AsObject()).WillOnce(Return(nullptr));
243         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(E_URIS));
244         shared_ptr<ConnectExtensionInfo> info2 = make_shared<ConnectExtensionInfo>();
245         result = proxy->RegisterNotify(uri, notifyForDescendants, observer, info2);
246         EXPECT_EQ(result, E_URIS);
247         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
248             .WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true));
249         EXPECT_CALL(*insMoc, Int()).WillOnce(Return(ERR_OK));
250         EXPECT_CALL(*observer, AsObject()).WillOnce(Return(nullptr));
251         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
252         result = proxy->RegisterNotify(uri, notifyForDescendants, observer, info2);
253         EXPECT_EQ(result, ERR_OK);
254         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
255             .WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true));
256         EXPECT_CALL(*insMoc, Int()).WillOnce(Return(E_IPCS));
257         EXPECT_CALL(*observer, AsObject()).WillOnce(Return(nullptr));
258         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
259         result = proxy->RegisterNotify(uri, notifyForDescendants, observer, info2);
260         EXPECT_EQ(result, E_IPCS);
261     } catch (...) {
262         GTEST_LOG_(ERROR) << "FileAccessServiceProxyTest occurs an exception.";
263     }
264     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-end file_access_service_proxy_RegisterNotify_0000";
265 }
266 
267 /**
268  * @tc.number: user_file_service_file_access_service_proxy_UnregisterNotifyInternal_0000
269  * @tc.name: file_access_service_proxy_UnregisterNotifyInternal_0000
270  * @tc.desc: Test function of UnregisterNotifyInternal interface for ERROR.
271  * @tc.size: MEDIUM
272  * @tc.type: FUNC
273  * @tc.level Level 3
274  * @tc.require: issuesI8Y05B
275  */
276 HWTEST_F(FileAccessServiceProxyTest, file_access_service_proxy_UnregisterNotifyInternal_0000,
277     testing::ext::TestSize.Level1)
278 {
279     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-begin file_access_service_proxy_UnregisterNotifyInternal_0000";
280     try {
281         shared_ptr<FileAccessServiceProxy> proxy = make_shared<FileAccessServiceProxy>(impl);
282         MessageParcel data;
283 
284         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(E_URIS));
285         auto result = proxy->UnregisterNotifyInternal(data);
286         EXPECT_EQ(result, E_URIS);
287         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
288         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(false));
289         EXPECT_CALL(*insMoc, Int()).WillOnce(Return(ERR_OK));
290         result = proxy->UnregisterNotifyInternal(data);
291         EXPECT_EQ(result, ERR_OK);
292         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
293         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true));
294         EXPECT_CALL(*insMoc, Int()).WillOnce(Return(E_IPCS));
295         result = proxy->UnregisterNotifyInternal(data);
296         EXPECT_EQ(result, E_IPCS);
297     } catch (...) {
298         GTEST_LOG_(ERROR) << "FileAccessServiceProxyTest occurs an exception.";
299     }
300     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-end file_access_service_proxy_UnregisterNotifyInternal_0000";
301 }
302 
303 /**
304  * @tc.number: user_file_service_file_access_service_proxy_UnregisterNotify_0000
305  * @tc.name: file_access_service_proxy_UnregisterNotify_0000
306  * @tc.desc: Test function of UnregisterNotify interface for ERROR.
307  * @tc.size: MEDIUM
308  * @tc.type: FUNC
309  * @tc.level Level 3
310  * @tc.require: issuesI8Y05B
311  */
312 HWTEST_F(FileAccessServiceProxyTest, file_access_service_proxy_UnregisterNotify_0000,
313     testing::ext::TestSize.Level1)
314 {
315     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-begin file_access_service_proxy_UnregisterNotify_0000";
316     try {
317         shared_ptr<FileAccessServiceProxy> proxy = make_shared<FileAccessServiceProxy>(impl);
318         Uri uri("");
319         sptr<IFileAccessObserverMock> observer = nullptr;
320         shared_ptr<ConnectExtensionInfo> info = nullptr;
321         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(false));
322         auto result = proxy->UnregisterNotify(uri, observer, info);
323         EXPECT_EQ(result, E_IPCS);
324         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(false));
325         result = proxy->UnregisterNotify(uri, observer, info);
326         EXPECT_EQ(result, E_IPCS);
327         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(false));
328         result = proxy->UnregisterNotify(uri, observer, info);
329         EXPECT_EQ(result, E_IPCS);
330         observer = sptr<IFileAccessObserverMock>(new IFileAccessObserverMock());
331         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(false));
332         result = proxy->UnregisterNotify(uri, observer, info);
333         EXPECT_EQ(result, E_IPCS);
334         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
335             .WillOnce(Return(false));
336         EXPECT_CALL(*observer, AsObject()).WillOnce(Return(nullptr));
337         result = proxy->UnregisterNotify(uri, observer, info);
338         EXPECT_EQ(result, E_IPCS);
339         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
340             .WillOnce(Return(false));
341         EXPECT_CALL(*observer, AsObject()).WillOnce(Return(nullptr));
342         result = proxy->UnregisterNotify(uri, observer, info);
343         EXPECT_EQ(result, E_IPCS);
344     } catch (...) {
345         GTEST_LOG_(ERROR) << "FileAccessServiceProxyTest occurs an exception.";
346     }
347     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-end file_access_service_proxy_UnregisterNotify_0000";
348 }
349 
350 /**
351  * @tc.number: user_file_service_file_access_service_proxy_GetExensionProxy_0000
352  * @tc.name: file_access_service_proxy_GetExensionProxy_0000
353  * @tc.desc: Test function of GetExtensionProxy interface for ERROR.
354  * @tc.size: MEDIUM
355  * @tc.type: FUNC
356  * @tc.level Level 3
357  * @tc.require: issuesI8Y05B
358  */
359 HWTEST_F(FileAccessServiceProxyTest, file_access_service_proxy_GetExensionProxy_0000, testing::ext::TestSize.Level1)
360 {
361     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-begin file_access_service_proxy_GetExensionProxy_0000";
362     try {
363         shared_ptr<FileAccessServiceProxy> proxy = make_shared<FileAccessServiceProxy>(impl);
364 
365         shared_ptr<ConnectExtensionInfo> info = nullptr;
366         sptr<IFileAccessExtBase> extensionProxy = nullptr;
367         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(false));
368         auto result = proxy->GetExtensionProxy(info, extensionProxy);
369         EXPECT_EQ(result, E_IPCS);
370         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true));
371         result = proxy->GetExtensionProxy(info, extensionProxy);
372         EXPECT_EQ(result, E_GETINFO);
373         info = make_shared<ConnectExtensionInfo>();
374         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(false));
375         result = proxy->GetExtensionProxy(info, extensionProxy);
376         EXPECT_EQ(result, E_IPCS);
377         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true));
378         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(E_URIS));
379         result = proxy->GetExtensionProxy(info, extensionProxy);
380         EXPECT_EQ(result, E_URIS);
381         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
382             .WillOnce(Return(false));
383         EXPECT_CALL(*insMoc, Int()).WillOnce(Return(ERR_OK));
384         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
385         result = proxy->GetExtensionProxy(info, extensionProxy);
386         EXPECT_EQ(result, ERR_OK);
387         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
388             .WillOnce(Return(true));
389         EXPECT_CALL(*insMoc, Int()).WillOnce(Return(E_IPCS));
390         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
391         result = proxy->GetExtensionProxy(info, extensionProxy);
392         EXPECT_EQ(result, E_IPCS);
393         EXPECT_CALL(*insMoc, Bool()).WillOnce(Return(true)).WillOnce(Return(true)).WillOnce(Return(true))
394             .WillOnce(Return(true));
395         EXPECT_CALL(*insMoc, Int()).WillOnce(Return(ERR_OK));
396         EXPECT_CALL(*impl, SendRequest(_, _, _, _)).WillOnce(Return(ERR_OK));
397         result = proxy->GetExtensionProxy(info, extensionProxy);
398         EXPECT_EQ(result, E_IPCS);
399     } catch (...) {
400         GTEST_LOG_(ERROR) << "FileAccessServiceProxyTest occurs an exception.";
401     }
402     GTEST_LOG_(INFO) << "FileAccessServiceProxyTest-end file_access_service_proxy_GetExensionProxy_0000";
403 }
404 }