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/include/extension_session_manager.h"
18 #include "session/host/include/extension_session.h"
19 #include "window_manager_hilog.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace Rosen {
26 class ExtensionSessionManagerTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp() override;
31 void TearDown() override;
32
33 private:
34 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
35 };
36
SetUpTestCase()37 void ExtensionSessionManagerTest::SetUpTestCase() {}
38
TearDownTestCase()39 void ExtensionSessionManagerTest::TearDownTestCase() {}
40
SetUp()41 void ExtensionSessionManagerTest::SetUp() {}
42
TearDown()43 void ExtensionSessionManagerTest::TearDown() {}
44
45 namespace {
46 /**
47 * @tc.name: RequestExtensionSession
48 * @tc.desc: RequestExtensionSession Test
49 * @tc.type: FUNC
50 */
51 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSession, TestSize.Level1)
52 {
53 SessionInfo sessionInfo;
54 sessionInfo.abilityName_ = "RequestExtensionSession";
55 ASSERT_NE(nullptr, ExtensionSessionManager::GetInstance().RequestExtensionSession(sessionInfo));
56 }
57
58 /**
59 * @tc.name: RequestExtensionSessionActivation01
60 * @tc.desc: RequestExtensionSessionActivation Test
61 * @tc.type: FUNC
62 */
63 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionActivation01, TestSize.Level1)
64 {
65 SessionInfo info;
66 sptr<ExtensionSession> extensionSession = sptr<ExtensionSession>::MakeSptr(info);
67 ASSERT_EQ(WSError::WS_OK,
68 ExtensionSessionManager::GetInstance().RequestExtensionSessionBackground(extensionSession, nullptr));
69 }
70
func(WSError we)71 void func(WSError we) {}
72
73 /**
74 * @tc.name: RequestExtensionSessionActivation02
75 * @tc.desc: RequestExtensionSessionActivation Test
76 * @tc.type: FUNC
77 */
78 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionActivation02, TestSize.Level1)
79 {
80 SessionInfo info;
81 sptr<ExtensionSession> extensionSession = sptr<ExtensionSession>::MakeSptr(info);
82 ExtensionSessionManager* instance = &ExtensionSessionManager::GetInstance();
83 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionActivation(extensionSession, 1, nullptr));
84 usleep(WAIT_SYNC_IN_NS);
85
86 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionActivation(extensionSession, 1, (func)));
87 usleep(WAIT_SYNC_IN_NS);
88
89 extensionSession->persistentId_ = -1;
90 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionActivation(extensionSession, 1, nullptr));
91 usleep(WAIT_SYNC_IN_NS);
92 }
93
94 /**
95 * @tc.name: RequestExtensionSessionBackground01
96 * @tc.desc: RequestExtensionSessionBackground Test
97 * @tc.type: FUNC
98 */
99 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionBackground01, TestSize.Level1)
100 {
101 SessionInfo info;
102 sptr<ExtensionSession> extensionSession = sptr<ExtensionSession>::MakeSptr(info);
103 ASSERT_EQ(WSError::WS_OK,
104 ExtensionSessionManager::GetInstance().RequestExtensionSessionBackground(extensionSession, nullptr));
105 }
106
107 /**
108 * @tc.name: RequestExtensionSessionBackground02
109 * @tc.desc: RequestExtensionSessionBackground Test
110 * @tc.type: FUNC
111 */
112 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionBackground02, TestSize.Level1)
113 {
114 SessionInfo info;
115 sptr<ExtensionSession> extensionSession = sptr<ExtensionSession>::MakeSptr(info);
116 ExtensionSessionManager* instance = &ExtensionSessionManager::GetInstance();
117 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionBackground(extensionSession, nullptr));
118 usleep(WAIT_SYNC_IN_NS);
119
120 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionBackground(extensionSession, func));
121 usleep(WAIT_SYNC_IN_NS);
122
123 extensionSession->persistentId_ = -1;
124 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionBackground(extensionSession, nullptr));
125 usleep(WAIT_SYNC_IN_NS);
126 }
127
128 /**
129 * @tc.name: RequestExtensionSessionDestruction01
130 * @tc.desc: RequestExtensionSessionDestruction Test
131 * @tc.type: FUNC
132 */
133 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionDestruction01, TestSize.Level1)
134 {
135 SessionInfo info;
136 sptr<ExtensionSession> extensionSession = sptr<ExtensionSession>::MakeSptr(info);
137 ASSERT_EQ(WSError::WS_OK,
138 ExtensionSessionManager::GetInstance().RequestExtensionSessionDestruction(extensionSession, nullptr));
139 }
140
141 /**
142 * @tc.name: RequestExtensionSessionDestructionDone01
143 * @tc.desc: RequestExtensionSessionDestructionDone Test
144 * @tc.type: FUNC
145 */
146 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionDestructionDone01, TestSize.Level1)
147 {
148 SessionInfo info;
149 sptr<ExtensionSession> extensionSession = new ExtensionSession(info);
150 ASSERT_EQ(WSError::WS_OK,
151 ExtensionSessionManager::GetInstance().RequestExtensionSessionDestructionDone(extensionSession));
152 }
153
154 /**
155 * @tc.name: RequestExtensionSessionDestruction03
156 * @tc.desc: RequestExtensionSessionDestruction Test
157 * @tc.type: FUNC
158 */
159 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionDestruction03, TestSize.Level1)
160 {
161 SessionInfo info;
162 sptr<ExtensionSession> extensionSession = sptr<ExtensionSession>::MakeSptr(info);
163 ExtensionSessionManager* instance = &ExtensionSessionManager::GetInstance();
164 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionDestruction(extensionSession, nullptr));
165 usleep(WAIT_SYNC_IN_NS);
166
167 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionDestruction(extensionSession, func));
168 usleep(WAIT_SYNC_IN_NS);
169
170 extensionSession->persistentId_ = -1;
171 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionDestruction(extensionSession, nullptr));
172 usleep(WAIT_SYNC_IN_NS);
173 }
174
175 /**
176 * @tc.name: RequestExtensionSessionDestructionDone03
177 * @tc.desc: RequestExtensionSessionDestructionDone Test
178 * @tc.type: FUNC
179 */
180 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionDestructionDone03, TestSize.Level1)
181 {
182 SessionInfo info;
183 sptr<ExtensionSession> extensionSession = new ExtensionSession(info);
184 ExtensionSessionManager* instance = &ExtensionSessionManager::GetInstance();
185 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionDestructionDone(extensionSession));
186 usleep(WAIT_SYNC_IN_NS);
187
188 extensionSession->persistentId_ = -1;
189 ASSERT_EQ(WSError::WS_OK, instance->RequestExtensionSessionDestructionDone(extensionSession));
190 usleep(WAIT_SYNC_IN_NS);
191 }
192
193 /**
194 * @tc.name: GetInstance
195 * @tc.desc: ExtensionSessionManager get instance and init
196 * @tc.type: FUNC
197 */
198 HWTEST_F(ExtensionSessionManagerTest, GetInstance, TestSize.Level1)
199 {
200 ExtensionSessionManager* instance = &ExtensionSessionManager::GetInstance();
201 ASSERT_NE(nullptr, instance);
202 }
203
204 /**
205 * @tc.name: SetAbilitySessionInfo
206 * @tc.desc: ExtensionSessionManager set ability session info
207 * @tc.type: FUNC
208 */
209 HWTEST_F(ExtensionSessionManagerTest, SetAbilitySessionInfo, TestSize.Level1)
210 {
211 AAFwk::Want want;
212 SessionInfo infoInput;
213 infoInput.want = std::make_shared<AAFwk::Want>(want);
214 sptr<ExtensionSession> extSession = new ExtensionSession(infoInput);
215 ExtensionSessionManager* instance = &ExtensionSessionManager::GetInstance();
216 sptr<AAFwk::SessionInfo> result = instance->SetAbilitySessionInfo(extSession);
217 int32_t persistentId = extSession->GetPersistentId();
218 ASSERT_EQ(result->persistentId, persistentId);
219
220 result = instance->SetAbilitySessionInfo(extSession);
221 extSession->sessionInfo_.want = nullptr;
222 ASSERT_EQ(result->persistentId, persistentId);
223 }
224
225 /**
226 * @tc.name: RequestExtensionSessionDestruction02
227 * @tc.desc: RequestExtensionSessionDestruction Test
228 * @tc.type: FUNC
229 */
230 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionDestruction02, TestSize.Level1)
231 {
232 AAFwk::Want want;
233 SessionInfo infoInput;
234 infoInput.want = std::make_shared<AAFwk::Want>(want);
235 sptr<ExtensionSession> extSession = nullptr;
236 ExtensionSessionManager* instance = &ExtensionSessionManager::GetInstance();
237 WSError result01 = instance->RequestExtensionSessionDestruction(extSession, nullptr);
238 EXPECT_EQ(result01, WSError::WS_OK);
239 }
240
241 /**
242 * @tc.name: RequestExtensionSessionDestructionDone02
243 * @tc.desc: RequestExtensionSessionDestructionDone Test
244 * @tc.type: FUNC
245 */
246 HWTEST_F(ExtensionSessionManagerTest, RequestExtensionSessionDestructionDone02, TestSize.Level1)
247 {
248 AAFwk::Want want;
249 SessionInfo infoInput;
250 infoInput.want = std::make_shared<AAFwk::Want>(want);
251 sptr<ExtensionSession> extSession = nullptr;
252 ExtensionSessionManager* instance = &ExtensionSessionManager::GetInstance();
253 WSError result01 = instance->RequestExtensionSessionDestructionDone(extSession);
254 EXPECT_EQ(result01, WSError::WS_OK);
255 }
256 } // namespace
257 } // namespace Rosen
258 } // namespace OHOS
259