1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include "session_manager.h"
18 
19 #include <iservice_registry.h>
20 #include <system_ability_definition.h>
21 #include <ipc_skeleton.h>
22 
23 #include "session_manager_service_recover_interface.h"
24 #include "singleton_delegator.h"
25 #include "window_manager_hilog.h"
26 #include "session_manager_lite.h"
27 
28 using namespace testing;
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace Rosen {
33 class SessionManagerTest : public testing::Test {
34 public:
35     static void SetUpTestCase();
36     static void TearDownTestCase();
37     void SetUp() override;
38     void TearDown() override;
39 };
40 
SetUpTestCase()41 void SessionManagerTest::SetUpTestCase()
42 {
43 }
44 
TearDownTestCase()45 void SessionManagerTest::TearDownTestCase()
46 {
47 }
48 
SetUp()49 void SessionManagerTest::SetUp()
50 {
51 }
52 
TearDown()53 void SessionManagerTest::TearDown()
54 {
55 }
56 
57 namespace {
58 constexpr int32_t MOCK_USER_ID_ZERO = 0;
59 constexpr int32_t MOCK_SCREEN_ID_ZERO = 0;
60 /**
61  * @tc.name: OnRemoteRequest
62  * @tc.desc: normal function
63  * @tc.type: FUNC
64  */
65 HWTEST_F(SessionManagerTest, OnRemoteRequest, Function | SmallTest | Level2)
66 {
67     OHOS::MessageParcel data;
68     OHOS::MessageParcel reply;
69     OHOS::MessageOption option;
70     IPCObjectStub iPCObjectStub;
71 
72     uint32_t code = static_cast<uint32_t>(OHOS::Rosen::ISessionManagerServiceRecoverListener::
73         SessionManagerServiceRecoverMessage::TRANS_ID_ON_SESSION_MANAGER_SERVICE_RECOVER);
74     auto ret = iPCObjectStub.OnRemoteRequest(code, data, reply, option);
75     ASSERT_NE(ret, 0);
76 
77     code = static_cast<uint32_t>(OHOS::Rosen::ISessionManagerServiceRecoverListener::
78         SessionManagerServiceRecoverMessage::TRANS_ID_ON_WMS_CONNECTION_CHANGED);
79     ret = iPCObjectStub.OnRemoteRequest(code, data, reply, option);
80     ASSERT_NE(ret, 0);
81 
82     code = 10;
83     ret = iPCObjectStub.OnRemoteRequest(code, data, reply, option);
84     ASSERT_NE(0, ret);
85 }
86 
87 /**
88  * @tc.name: OnWMSConnectionChangedCallback
89  * @tc.desc: normal function
90  * @tc.type: FUNC
91  */
92 HWTEST_F(SessionManagerTest, OnWMSConnectionChangedCallback, Function | SmallTest | Level2)
93 {
94     SessionManager sessionManager;
95     sessionManager.wmsConnectionChangedFunc_ = nullptr;
96     sessionManager.OnWMSConnectionChangedCallback(MOCK_USER_ID_ZERO, MOCK_SCREEN_ID_ZERO, true, false);
97 
98     sessionManager.currentWMSUserId_ = SYSTEM_USERID;
99 
100     sessionManager.ClearSessionManagerProxy();
101 
102     sptr<ISessionManagerService> sessionManagerService;
103     sessionManager.RecoverSessionManagerService(sessionManagerService);
__anon80ed8aaf0202() 104     sessionManager.RegisterUserSwitchListener([]() {});
105     sessionManager.OnUserSwitch(sessionManagerService);
106     sessionManager.Clear();
107 
108     sessionManager.isWMSConnected_ = true;
109     sessionManager.currentWMSUserId_ = SYSTEM_USERID;
110     SessionManager::WMSConnectionChangedCallbackFunc callbackFunc;
111     auto ret = sessionManager.RegisterWMSConnectionChangedListener(callbackFunc);
112     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
113 }
114 
115 /**
116  * @tc.name: OnWMSConnectionChanged
117  * @tc.desc: normal function
118  * @tc.type: FUNC
119  */
120 HWTEST_F(SessionManagerTest, OnWMSConnectionChanged, Function | SmallTest | Level2)
121 {
122     SessionManager sessionManager;
123     sptr<ISessionManagerService> sessionManagerService;
124 
125     sessionManager.OnWMSConnectionChanged(MOCK_USER_ID_ZERO, MOCK_SCREEN_ID_ZERO, false, sessionManagerService);
126 
127     sessionManager.currentWMSUserId_ = INVALID_UID + 100;
128     sessionManager.OnWMSConnectionChanged(MOCK_USER_ID_ZERO, MOCK_SCREEN_ID_ZERO, true, sessionManagerService);
129 
130     ASSERT_NE(sessionManager.currentWMSUserId_, INVALID_UID);
131 }
132 
133 /**
134  * @tc.name: ClearSessionManagerProxy
135  * @tc.desc: normal function
136  * @tc.type: FUNC
137  */
138 HWTEST_F(SessionManagerTest, ClearSessionManagerProxy, Function | SmallTest | Level2)
139 {
140     SessionManager sessionManager;
141 
142     sessionManager.ClearSessionManagerProxy();
143     ASSERT_EQ(sessionManager.sessionManagerServiceProxy_, nullptr);
144 
145     sessionManager.sessionManagerServiceProxy_ = nullptr;
146     sessionManager.ClearSessionManagerProxy();
147     ASSERT_EQ(sessionManager.sessionManagerServiceProxy_, nullptr);
148 
149     sptr<ISessionManagerService> sessionManagerServiceProxy;
150     sessionManager.sessionManagerServiceProxy_ = sessionManagerServiceProxy;
151     sessionManager.ClearSessionManagerProxy();
152     ASSERT_EQ(sessionManager.sessionManagerServiceProxy_, nullptr);
153 }
154 
155 /**
156  * @tc.name: RecoverSessionManagerService
157  * @tc.desc: normal function
158  * @tc.type: FUNC
159  */
160 HWTEST_F(SessionManagerTest, RecoverSessionManagerService, Function | SmallTest | Level2)
161 {
162     SessionManager sessionManager;
163 
164     bool funcInvoked = false;
165 
166     sessionManager.RecoverSessionManagerService(nullptr);
167     ASSERT_EQ(funcInvoked, false);
168 
__anon80ed8aaf0302() 169     sessionManager.windowManagerRecoverFunc_ = [&]()  {
170             funcInvoked = true;
171     };
172     sessionManager.RecoverSessionManagerService(nullptr);
173     ASSERT_EQ(funcInvoked, true);
174 }
175 
176 /**
177  * @tc.name: OnUserSwitch
178  * @tc.desc: normal function
179  * @tc.type: FUNC
180  */
181 HWTEST_F(SessionManagerTest, OnUserSwitch, Function | SmallTest | Level2)
182 {
183     SessionManager sessionManager;
184 
185     bool funcInvoked = false;
186     sessionManager.userSwitchCallbackFunc_ = nullptr;
187     sessionManager.OnUserSwitch(nullptr);
188     ASSERT_EQ(funcInvoked, false);
189 
190     std::function<void()> userSwitchCallbackFunc;
191     sessionManager.userSwitchCallbackFunc_ = userSwitchCallbackFunc;
192     sptr<ISessionManagerService> sessionManagerService;
193     sessionManager.OnUserSwitch(sessionManagerService);
194     ASSERT_EQ(funcInvoked, false);
195 }
196 
197 /**
198  * @tc.name: RegisterWMSConnectionChangedListener
199  * @tc.desc: normal function
200  * @tc.type: FUNC
201  */
202 HWTEST_F(SessionManagerTest, RegisterWMSConnectionChangedListener, Function | SmallTest | Level2)
203 {
204     SessionManager sessionManager;
205     sessionManager.OnFoundationDied();
206     FoundationDeathRecipient foundationDeathRecipient;
207     wptr<IRemoteObject> wptrDeath;
208     foundationDeathRecipient.OnRemoteDied(wptrDeath);
209     SSMDeathRecipient sSMDeathRecipient;
210     sSMDeathRecipient.OnRemoteDied(wptrDeath);
211 
212     wptrDeath = nullptr;
213     foundationDeathRecipient.OnRemoteDied(wptrDeath);
214     sSMDeathRecipient.OnRemoteDied(wptrDeath);
215 
216     SessionManager::WMSConnectionChangedCallbackFunc callbackFunc;
217     auto ret = sessionManager.RegisterWMSConnectionChangedListener(callbackFunc);
218     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
219 }
220 
221 /**
222  * @tc.name: RegisterSMSRecoverListener
223  * @tc.desc: normal function
224  * @tc.type: FUNC
225  */
226 HWTEST_F(SessionManagerTest, RegisterSMSRecoverListener, Function | SmallTest | Level2)
227 {
228     SessionManager sessionManager;
229     sessionManager.isRecoverListenerRegistered_ = false;
230     sessionManager.mockSessionManagerServiceProxy_ = nullptr;
231     sessionManager.RegisterSMSRecoverListener();
232     ASSERT_EQ(sessionManager.mockSessionManagerServiceProxy_, nullptr);
233 }
234 
235 /**
236  * @tc.name: InitMockSMSProxy
237  * @tc.desc: normal function
238  * @tc.type: FUNC
239  */
240 HWTEST_F(SessionManagerTest, InitMockSMSProxy, Function | SmallTest | Level2)
241 {
242     SessionManager sessionManager;
243     sessionManager.InitMockSMSProxy();
244     sessionManager.InitMockSMSProxy();
245     ASSERT_NE(sessionManager.foundationDeath_, nullptr);
246 }
247 }
248 }
249 }