• 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 #include "session_proxy.h"
16 #include "iremote_object_mocker.h"
17 #include <gtest/gtest.h>
18 #include "accessibility_event_info.h"
19 #include "ws_common.h"
20 #include "mock_message_parcel.h"
21 
22 // using namespace FRAME_TRACE;
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS {
27 namespace Rosen {
28 class SessionProxyTest : public testing::Test {
29   public:
SessionProxyTest()30     SessionProxyTest() {}
~SessionProxyTest()31     ~SessionProxyTest() {}
32 };
33 namespace {
34 
35 /**
36  * @tc.name: WriteAbilitySessionInfoBasic
37  * @tc.desc: normal function
38  * @tc.type: FUNC
39  */
40 HWTEST_F(SessionProxyTest, WriteAbilitySessionInfoBasic, Function | SmallTest | Level2)
41 {
42     GTEST_LOG_(INFO) << "SessionProxyTest: WriteAbilitySessionInfoBasic start";
43     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
44     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
45     sptr<AAFwk::SessionInfo> abilitySessionInfo = nullptr;
46     MessageParcel data;
47     bool res = sProxy->WriteAbilitySessionInfoBasic(data, abilitySessionInfo);
48     ASSERT_EQ(res, false);
49 
50     sptr<AAFwk::SessionInfo> abilitySessionInfo1 = new(std::nothrow) AAFwk::SessionInfo();
51     ASSERT_NE(abilitySessionInfo1, nullptr);
52     res = sProxy->WriteAbilitySessionInfoBasic(data, abilitySessionInfo1);
53     ASSERT_EQ(res, false);
54     GTEST_LOG_(INFO) << "SessionProxyTest: WriteAbilitySessionInfoBasic end";
55 }
56 
57 /**
58  * @tc.name: OnSessionEvent
59  * @tc.desc: normal function
60  * @tc.type: FUNC
61  */
62 HWTEST_F(SessionProxyTest, OnSessionEvent, Function | SmallTest | Level2)
63 {
64     GTEST_LOG_(INFO) << "SessionProxyTest: OnSessionEvent start";
65     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
66     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
67     SessionEvent event = SessionEvent::EVENT_MAXIMIZE;
68     WSError res = sProxy->OnSessionEvent(event);
69     ASSERT_EQ(res, WSError::WS_OK);
70     GTEST_LOG_(INFO) << "SessionProxyTest: OnSessionEvent end";
71 }
72 
73 /**
74  * @tc.name: UpdateSessionRect
75  * @tc.desc: normal function
76  * @tc.type: FUNC
77  */
78 HWTEST_F(SessionProxyTest, UpdateSessionRect, Function | SmallTest | Level2)
79 {
80     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateSessionRect start";
81     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
82     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
83     WSRect rect{.posX_ = 1, .posY_ = 1, .width_ = 100, .height_ = 100};
84     SizeChangeReason reason = SizeChangeReason::RECOVER;
85     WSError res = sProxy->UpdateSessionRect(rect, reason);
86     ASSERT_EQ(res, WSError::WS_OK);
87     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateSessionRect end";
88 }
89 
90 /**
91  * @tc.name: RaiseToAppTop
92  * @tc.desc: normal function
93  * @tc.type: FUNC
94  */
95 HWTEST_F(SessionProxyTest, RaiseToAppTop, Function | SmallTest | Level2)
96 {
97     GTEST_LOG_(INFO) << "SessionProxyTest: RaiseToAppTop start";
98     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
99     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
100     WSError res = sProxy->RaiseToAppTop();
101     ASSERT_EQ(res, WSError::WS_OK);
102 
103     GTEST_LOG_(INFO) << "SessionProxyTest: RaiseToAppTop end";
104 }
105 
106 /**
107  * @tc.name: OnNeedAvoid
108  * @tc.desc: normal function
109  * @tc.type: FUNC
110  */
111 HWTEST_F(SessionProxyTest, OnNeedAvoid, Function | SmallTest | Level2)
112 {
113     GTEST_LOG_(INFO) << "SessionProxyTest: OnNeedAvoid start";
114     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
115     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
116     bool status = false;
117     WSError res = sProxy->OnNeedAvoid(status);
118     ASSERT_EQ(res, WSError::WS_OK);
119 
120     GTEST_LOG_(INFO) << "SessionProxyTest: OnNeedAvoid end";
121 }
122 
123 /**
124  * @tc.name: GetAvoidAreaByType
125  * @tc.desc: normal function
126  * @tc.type: FUNC
127  */
128 HWTEST_F(SessionProxyTest, GetAvoidAreaByType, Function | SmallTest | Level2)
129 {
130     GTEST_LOG_(INFO) << "SessionProxyTest: GetAvoidAreaByType start";
131     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
132     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
133     AvoidAreaType status = AvoidAreaType::TYPE_SYSTEM;
134     AvoidArea res = sProxy->GetAvoidAreaByType(status);
135     AvoidArea area;
136     ASSERT_EQ(res, area);
137 
138     GTEST_LOG_(INFO) << "SessionProxyTest: GetAvoidAreaByType end";
139 }
140 
141 /**
142  * @tc.name: RequestSessionBack
143  * @tc.desc: normal function
144  * @tc.type: FUNC
145  */
146 HWTEST_F(SessionProxyTest, RequestSessionBack, Function | SmallTest | Level2)
147 {
148     GTEST_LOG_(INFO) << "SessionProxyTest: RequestSessionBack start";
149     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
150     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
151     bool needMoveToBackground = true;
152     WSError res = sProxy->RequestSessionBack(needMoveToBackground);
153     ASSERT_EQ(res, WSError::WS_OK);
154 
155     GTEST_LOG_(INFO) << "SessionProxyTest: RequestSessionBack end";
156 }
157 
158 /**
159  * @tc.name: MarkProcessed
160  * @tc.desc: normal function
161  * @tc.type: FUNC
162  */
163 HWTEST_F(SessionProxyTest, MarkProcessed, Function | SmallTest | Level2)
164 {
165     GTEST_LOG_(INFO) << "SessionProxyTest: MarkProcessed start";
166     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
167     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
168     int32_t eventId = 0;
169     WSError res = sProxy->MarkProcessed(eventId);
170     ASSERT_EQ(res, WSError::WS_OK);
171 
172     GTEST_LOG_(INFO) << "SessionProxyTest: MarkProcessed end";
173 }
174 
175 /**
176  * @tc.name: SetGlobalMaximizeMode
177  * @tc.desc: normal function
178  * @tc.type: FUNC
179  */
180 HWTEST_F(SessionProxyTest, SetGlobalMaximizeMode, Function | SmallTest | Level2)
181 {
182     GTEST_LOG_(INFO) << "SessionProxyTest: SetGlobalMaximizeMode start";
183     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
184     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
185     MaximizeMode mode = MaximizeMode::MODE_AVOID_SYSTEM_BAR;
186     WSError res = sProxy->SetGlobalMaximizeMode(mode);
187     ASSERT_EQ(res, WSError::WS_OK);
188 
189     GTEST_LOG_(INFO) << "SessionProxyTest: SetGlobalMaximizeMode end";
190 }
191 
192 /**
193  * @tc.name: GetGlobalMaximizeMode
194  * @tc.desc: normal function
195  * @tc.type: FUNC
196  */
197 HWTEST_F(SessionProxyTest, GetGlobalMaximizeMode, Function | SmallTest | Level2)
198 {
199     GTEST_LOG_(INFO) << "SessionProxyTest: GetGlobalMaximizeMode start";
200     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
201     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
202     MaximizeMode mode = MaximizeMode::MODE_AVOID_SYSTEM_BAR;
203     WSError res = sProxy->GetGlobalMaximizeMode(mode);
204     ASSERT_EQ(res, WSError::WS_OK);
205 
206     GTEST_LOG_(INFO) << "SessionProxyTest: GetGlobalMaximizeMode end";
207 }
208 
209 /**
210  * @tc.name: SetAspectRatio
211  * @tc.desc: normal function
212  * @tc.type: FUNC
213  */
214 HWTEST_F(SessionProxyTest, SetAspectRatio, Function | SmallTest | Level2)
215 {
216     GTEST_LOG_(INFO) << "SessionProxyTest: SetAspectRatio start";
217     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
218     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
219     float ratio = 10;
220     WSError res = sProxy->SetAspectRatio(ratio);
221     ASSERT_EQ(res, WSError::WS_OK);
222 
223     GTEST_LOG_(INFO) << "SessionProxyTest: SetAspectRatio end";
224 }
225 
226 /**
227  * @tc.name: UpdateSessionPropertyByAction01
228  * @tc.desc: UpdateSessionPropertyByAction
229  * @tc.type: FUNC
230  */
231 HWTEST_F(SessionProxyTest, UpdateSessionPropertyByAction01, Function | SmallTest | Level2)
232 {
233     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateSessionPropertyByAction01 start";
234     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
235     ASSERT_NE(iRemoteObjectMocker, nullptr);
236     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
237     ASSERT_NE(sProxy, nullptr);
238     WMError res = sProxy->UpdateSessionPropertyByAction(nullptr,
239         WSPropertyChangeAction::ACTION_UPDATE_KEEP_SCREEN_ON);
240     ASSERT_EQ(res, WMError::WM_OK);
241     delete sProxy;
242     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateSessionPropertyByAction01 end";
243 }
244 
245 /**
246  * @tc.name: UpdateSessionPropertyByAction02
247  * @tc.desc: UpdateSessionPropertyByAction
248  * @tc.type: FUNC
249  */
250 HWTEST_F(SessionProxyTest, UpdateSessionPropertyByAction02, Function | SmallTest | Level2)
251 {
252     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateSessionPropertyByAction02 start";
253     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
254     ASSERT_NE(iRemoteObjectMocker, nullptr);
255     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
256     ASSERT_NE(sProxy, nullptr);
257     WMError res = sProxy->UpdateSessionPropertyByAction(nullptr,
258         WSPropertyChangeAction::ACTION_UPDATE_TURN_SCREEN_ON);
259     ASSERT_EQ(res, WMError::WM_OK);
260     delete sProxy;
261     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateSessionPropertyByAction02 end";
262 }
263 
264 /**
265  * @tc.name: UpdateWindowSceneAfterCustomAnimation
266  * @tc.desc: normal function
267  * @tc.type: FUNC
268  */
269 HWTEST_F(SessionProxyTest, UpdateWindowSceneAfterCustomAnimation, Function | SmallTest | Level2)
270 {
271     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateWindowSceneAfterCustomAnimation start";
272     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
273     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
274     bool isAdd = false;
275     WSError res = sProxy->UpdateWindowSceneAfterCustomAnimation(isAdd);
276     ASSERT_EQ(res, WSError::WS_OK);
277 
278     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateWindowSceneAfterCustomAnimation end";
279 }
280 
281 /**
282  * @tc.name: TransferAbilityResult
283  * @tc.desc: normal function
284  * @tc.type: FUNC
285  */
286 HWTEST_F(SessionProxyTest, TransferAbilityResult, Function | SmallTest | Level2)
287 {
288     GTEST_LOG_(INFO) << "SessionProxyTest: TransferAbilityResult start";
289     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
290     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
291     uint32_t resultCode = 0;
292     AAFwk::Want want;
293     WSError res = sProxy->TransferAbilityResult(resultCode, want);
294     ASSERT_EQ(res, WSError::WS_OK);
295 
296     GTEST_LOG_(INFO) << "SessionProxyTest: TransferAbilityResult end";
297 }
298 
299 /**
300  * @tc.name: NotifyExtensionDied
301  * @tc.desc: normal function
302  * @tc.type: FUNC
303  */
304 HWTEST_F(SessionProxyTest, NotifyExtensionDied, Function | SmallTest | Level2)
305 {
306     GTEST_LOG_(INFO) << "SessionProxyTest: NotifyExtensionDied start";
307     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
308     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
309     sProxy->NotifyExtensionDied();
310 
311     GTEST_LOG_(INFO) << "SessionProxyTest: NotifyExtensionDied end";
312 }
313 
314 /**
315  * @tc.name: NotifyExtensionTimeout
316  * @tc.desc: normal function
317  * @tc.type: FUNC
318  */
319 HWTEST_F(SessionProxyTest, NotifyExtensionTimeout, Function | SmallTest | Level2)
320 {
321     GTEST_LOG_(INFO) << "SessionProxyTest: NotifyExtensionTimeout start";
322     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
323     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
324     sProxy->NotifyExtensionTimeout(2);
325 
326     GTEST_LOG_(INFO) << "SessionProxyTest: NotifyExtensionTimeout end";
327 }
328 
329 /**
330  * @tc.name: UpdateWindowAnimationFlag
331  * @tc.desc: normal function
332  * @tc.type: FUNC
333  */
334 HWTEST_F(SessionProxyTest, UpdateWindowAnimationFlag, Function | SmallTest | Level2)
335 {
336     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateWindowAnimationFlag start";
337     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
338     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
339     bool needDefaultAnimationFlag = false;
340     WSError res = sProxy->UpdateWindowAnimationFlag(needDefaultAnimationFlag);
341     ASSERT_EQ(res, WSError::WS_OK);
342 
343     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateWindowAnimationFlag end";
344 }
345 
346 /**
347  * @tc.name: TransferAccessibilityEvent
348  * @tc.desc: normal function
349  * @tc.type: FUNC
350  */
351 HWTEST_F(SessionProxyTest, TransferAccessibilityEvent, Function | SmallTest | Level2)
352 {
353     GTEST_LOG_(INFO) << "SessionProxyTest: TransferAccessibilityEvent start";
354     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
355     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
356     Accessibility::AccessibilityEventInfo info;
357     int64_t uiExtensionIdLevel = 0;
358     WSError res = sProxy->TransferAccessibilityEvent(info, uiExtensionIdLevel);
359     ASSERT_EQ(res, WSError::WS_OK);
360 
361     GTEST_LOG_(INFO) << "SessionProxyTest: TransferAccessibilityEvent end";
362 }
363 
364 /**
365  * @tc.name: UpdatePiPControlStatus
366  * @tc.desc: normal function
367  * @tc.type: FUNC
368  */
369 HWTEST_F(SessionProxyTest, UpdatePiPControlStatus, Function | SmallTest | Level2)
370 {
371     GTEST_LOG_(INFO) << "SessionProxyTest: UpdatePiPControlStatus start";
372     auto iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
373     ASSERT_NE(iRemoteObjectMocker, nullptr);
374     auto sProxy = sptr<SessionProxy>::MakeSptr(iRemoteObjectMocker);
375     ASSERT_NE(sProxy, nullptr);
376     auto controlType = WsPiPControlType::VIDEO_PLAY_PAUSE;
377     auto status = WsPiPControlStatus::PLAY;
378     WSError res = sProxy->UpdatePiPControlStatus(controlType, status);
379     ASSERT_EQ(res, WSError::WS_OK);
380     GTEST_LOG_(INFO) << "SessionProxyTest: UpdatePiPControlStatus end";
381 }
382 
383 /**
384  * @tc.name: SetAutoStartPiP
385  * @tc.desc: sessionStub sessionStubTest
386  * @tc.type: FUNC
387  * @tc.require: #I6JLSI
388  */
389 HWTEST_F(SessionProxyTest, SetAutoStartPiP, Function | SmallTest | Level2)
390 {
391     GTEST_LOG_(INFO) << "SetAutoStartPiP: SetAutoStartPiP start";
392     auto iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
393     ASSERT_NE(iRemoteObjectMocker, nullptr);
394     auto sProxy = sptr<SessionProxy>::MakeSptr(iRemoteObjectMocker);
395     ASSERT_NE(sProxy, nullptr);
396     bool isAutoStartValid = true;
397     uint32_t priority = 0;
398     ASSERT_EQ(WSError::WS_OK, sProxy->SetAutoStartPiP(isAutoStartValid, priority));
399     GTEST_LOG_(INFO) << "SetAutoStartPiP: SetAutoStartPiP end";
400 }
401 
402 /**
403  * @tc.name: GetGlobalScaledRect
404  * @tc.desc: normal function
405  * @tc.type: FUNC
406  */
407 HWTEST_F(SessionProxyTest, GetGlobalScaledRect, Function | SmallTest | Level2)
408 {
409     GTEST_LOG_(INFO) << "SessionProxyTest: GetGlobalScaledRect start";
410     Rect rect;
411     sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
412     sptr<SessionProxy> sProxy = sptr<SessionProxy>::MakeSptr(remoteMocker);
413     MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
414     WMError res = sProxy->GetGlobalScaledRect(rect);
415     ASSERT_EQ(res, WMError::WM_ERROR_IPC_FAILED);
416     MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
417 
418     sptr<SessionProxy> tempProxy = sptr<SessionProxy>::MakeSptr(nullptr);
419     res = tempProxy->GetGlobalScaledRect(rect);
420     ASSERT_EQ(res, WMError::WM_ERROR_IPC_FAILED);
421 
422     remoteMocker->SetRequestResult(ERR_INVALID_DATA);
423     res = sProxy->GetGlobalScaledRect(rect);
424     ASSERT_EQ(res, WMError::WM_ERROR_IPC_FAILED);
425     remoteMocker->SetRequestResult(ERR_NONE);
426 
427     MockMessageParcel::SetReadInt32ErrorFlag(true);
428     MockMessageParcel::SetReadUint32ErrorFlag(true);
429     res = sProxy->GetGlobalScaledRect(rect);
430     ASSERT_EQ(res, WMError::WM_ERROR_IPC_FAILED);
431 
432     MockMessageParcel::ClearAllErrorFlag();
433     res = sProxy->GetGlobalScaledRect(rect);
434     ASSERT_EQ(res, WMError::WM_OK);
435     GTEST_LOG_(INFO) << "SessionProxyTest: GetGlobalScaledRect end";
436 }
437 
438 /**
439  * @tc.name: RequestFocus
440  * @tc.desc: RequestFocus Test
441  * @tc.type: FUNC
442  */
443 HWTEST_F(SessionProxyTest, RequestFocus, Function | SmallTest | Level2)
444 {
445     GTEST_LOG_(INFO) << "SessionProxyTest: RequestFocus start";
446     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
447     SessionProxy* sProxy = new(std::nothrow) SessionProxy(iRemoteObjectMocker);
448     WSError res = sProxy->RequestFocus(true);
449     ASSERT_EQ(res, WSError::WS_OK);
450     GTEST_LOG_(INFO) << "SessionProxyTest: RequestFocus end";
451 }
452 
453 /**
454  * @tc.name: UpdateClientRect01
455  * @tc.desc: UpdateClientRect test
456  * @tc.type: FUNC
457  */
458 HWTEST_F(SessionProxyTest, UpdateClientRect01, Function | SmallTest | Level2)
459 {
460     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateClientRect01 start";
461     auto sProxy = sptr<SessionProxy>::MakeSptr(nullptr);
462     WSRect rect = { 200, 200, 200, 200 };
463     ASSERT_EQ(sProxy->UpdateClientRect(rect), WSError::WS_ERROR_IPC_FAILED);
464 
465     auto iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
466     sProxy = sptr<SessionProxy>::MakeSptr(iRemoteObjectMocker);
467     ASSERT_EQ(sProxy->UpdateClientRect(rect), WSError::WS_OK);
468     GTEST_LOG_(INFO) << "SessionProxyTest: UpdateClientRect01 start";
469 }
470 
471 /**
472  * @tc.name: GetAppForceLandscapeConfig
473  * @tc.desc: normal function
474  * @tc.type: FUNC
475  */
476 HWTEST_F(SessionProxyTest, GetAppForceLandscapeConfig, Function | SmallTest | Level2)
477 {
478     GTEST_LOG_(INFO) << "SessionProxyTest: GetAppForceLandscapeConfig start";
479     auto iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
480     ASSERT_NE(iRemoteObjectMocker, nullptr);
481     auto sProxy = sptr<SessionProxy>::MakeSptr(iRemoteObjectMocker);
482     ASSERT_NE(sProxy, nullptr);
483     AppForceLandscapeConfig config = {};
484     auto res = sProxy->GetAppForceLandscapeConfig(config);
485     ASSERT_EQ(res, WMError::WM_OK);
486     GTEST_LOG_(INFO) << "SessionProxyTest: GetAppForceLandscapeConfig end";
487 }
488 } // namespace
489 } // namespace Rosen
490 } // namespace OHOS
491