1 /*
2 * Copyright (c) 2022-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 <gtest/gtest.h>
17 #include <utility>
18 #include "avsession_service.h"
19 #include "session_stack.h"
20 #include "system_ability_definition.h"
21
22 using namespace testing::ext;
23 using namespace OHOS::AVSession;
24
25 namespace OHOS {
26 namespace AVSession {
27
28 class SessionStackTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 };
35
SetUpTestCase()36 void SessionStackTest::SetUpTestCase() {}
TearDownTestCase()37 void SessionStackTest::TearDownTestCase() {}
SetUp()38 void SessionStackTest::SetUp() {}
TearDown()39 void SessionStackTest::TearDown() {}
40
41 /**
42 * @tc.name: RemoveSession001
43 * @tc.desc: verifying session stack remove session
44 * @tc.type: FUNC
45 */
46 HWTEST_F(SessionStackTest, RemoveSession001, TestSize.Level0)
47 {
48 AVSessionService* avSessionService_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
49 ASSERT_TRUE(avSessionService_ != nullptr);
50
51 OHOS::AppExecFwk::ElementName elementName;
52 elementName.SetBundleName("test.ohos.avsession");
53 elementName.SetAbilityName("test.ability");
54 OHOS::sptr <AVSessionItem> item =
55 avSessionService_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
56 ASSERT_TRUE(item != nullptr);
57 auto uid = AVSessionUsersManager::GetInstance().GetCurrentUserId();
58 item->SetPid(getpid());
59 item->SetUid(uid);
60 std::string sessionId = item->GetDescriptor().sessionId_;
61 SessionStack sessionStack;
62 sessionStack.AddSession(getpid(), elementName.GetAbilityName(), item);
63
64 auto actual = sessionStack.RemoveSession("test");
65 EXPECT_EQ(actual, nullptr);
66
67 actual = sessionStack.RemoveSession(getpid(), "test");
68 EXPECT_EQ(actual, nullptr);
69
70 actual = sessionStack.RemoveSession(sessionId);
71 EXPECT_NE(actual, nullptr);
72
73 avSessionService_->HandleSessionRelease(sessionId);
74 }
75
76 /**
77 * @tc.name: RemoveSession002
78 * @tc.desc: verifying session stack remove session
79 * @tc.type: FUNC
80 */
81 HWTEST_F(SessionStackTest, RemoveSession002, TestSize.Level0)
82 {
83 AVSessionService* avSessionService_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
84 ASSERT_TRUE(avSessionService_ != nullptr);
85
86 OHOS::AppExecFwk::ElementName elementName;
87 elementName.SetBundleName("test.ohos.avsession");
88 elementName.SetAbilityName("test.ability");
89 OHOS::sptr <AVSessionItem> item =
90 avSessionService_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
91 ASSERT_TRUE(item != nullptr);
92 auto uid = AVSessionUsersManager::GetInstance().GetCurrentUserId();
93 item->SetPid(getpid());
94 item->SetUid(uid);
95 std::string sessionId = item->GetDescriptor().sessionId_;
96 SessionStack sessionStack;
97 sessionStack.AddSession(getpid(), elementName.GetAbilityName(), item);
98
99 auto actual = sessionStack.RemoveSession(1);
100 EXPECT_EQ(actual.size(), 0);
101
102 actual = sessionStack.RemoveSession(getpid());
103 EXPECT_NE(actual.size(), 0);
104
105 avSessionService_->HandleSessionRelease(sessionId);
106 }
107
108 /**
109 * @tc.name: AddSession001
110 * @tc.desc: verifying session stack add session
111 * @tc.type: FUNC
112 */
113 HWTEST_F(SessionStackTest, AddSession001, TestSize.Level0)
114 {
115 OHOS::AppExecFwk::ElementName elementName;
116 AVSessionService* avSessionService_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
117 ASSERT_TRUE(avSessionService_ != nullptr);
118 elementName.SetBundleName("test.ohos.avsession");
119 elementName.SetAbilityName("test.ability");
120 OHOS::sptr <AVSessionItem> item =
121 avSessionService_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
122 ASSERT_TRUE(item != nullptr);
123 auto uid = AVSessionUsersManager::GetInstance().GetCurrentUserId();
124 item->SetPid(getpid());
125 item->SetUid(uid);
126 std::string sessionId = item->GetDescriptor().sessionId_;
127 SessionStack sessionStack;
128 for (auto i = 0; i < SessionContainer::SESSION_NUM_MAX; i++) {
129 sessionStack.sessions_.insert(std::make_pair(std::make_pair(i, "test"), item));
130 }
131 auto ret = sessionStack.AddSession(getpid(), elementName.GetAbilityName(), item);
132 EXPECT_EQ(ret, ERR_SESSION_EXCEED_MAX);
133
134 avSessionService_->HandleSessionRelease(sessionId);
135 sessionStack.sessions_.clear();
136 }
137
138 /**
139 * @tc.name: GetSession001
140 * @tc.desc: verifying session stack get session
141 * @tc.type: FUNC
142 */
143 HWTEST_F(SessionStackTest, GetSession001, TestSize.Level0)
144 {
145 OHOS::AppExecFwk::ElementName elementName;
146 AVSessionService* avSessionService_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
147 ASSERT_TRUE(avSessionService_ != nullptr);
148 elementName.SetBundleName("test.ohos.avsession");
149 elementName.SetAbilityName("test.ability");
150 OHOS::sptr <AVSessionItem> item =
151 avSessionService_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
152 ASSERT_TRUE(item != nullptr);
153 auto uid = AVSessionUsersManager::GetInstance().GetCurrentUserId();
154 item->SetPid(getpid());
155 item->SetUid(uid);
156 std::string sessionId = item->GetDescriptor().sessionId_;
157 SessionStack sessionStack;
158 auto ret = sessionStack.GetSession(getpid(), elementName.GetAbilityName());
159 EXPECT_EQ(ret, nullptr);
160
161 sessionStack.AddSession(getpid(), elementName.GetAbilityName(), item);
162
163 ret = sessionStack.GetSession(getpid(), elementName.GetAbilityName());
164 EXPECT_NE(ret, nullptr);
165
166 avSessionService_->HandleSessionRelease(sessionId);
167 sessionStack.sessions_.clear();
168 }
169
170 /**
171 * @tc.name: GetSessionById001
172 * @tc.desc: verifying session stack get session by id
173 * @tc.type: FUNC
174 */
175 HWTEST_F(SessionStackTest, GetSessionById001, TestSize.Level0)
176 {
177 OHOS::AppExecFwk::ElementName elementName;
178 AVSessionService* avSessionService_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
179 ASSERT_TRUE(avSessionService_ != nullptr);
180 elementName.SetBundleName("test.ohos.avsession");
181 elementName.SetAbilityName("test.ability");
182 OHOS::sptr <AVSessionItem> item =
183 avSessionService_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
184 ASSERT_TRUE(item != nullptr);
185 auto uid = AVSessionUsersManager::GetInstance().GetCurrentUserId();
186 item->SetPid(getpid());
187 item->SetUid(uid);
188 std::string sessionId = item->GetDescriptor().sessionId_;
189 SessionStack sessionStack;
190 sessionStack.AddSession(getpid(), elementName.GetAbilityName(), item);
191 auto ret = sessionStack.GetSessionById("test");
192 EXPECT_EQ(ret, nullptr);
193
194 avSessionService_->HandleSessionRelease(sessionId);
195 sessionStack.sessions_.clear();
196 }
197
198 /**
199 * @tc.name: UidHasSession001
200 * @tc.desc: verifying session stack UidHasSession
201 * @tc.type: FUNC
202 */
203 HWTEST_F(SessionStackTest, UidHasSession001, TestSize.Level0)
204 {
205 OHOS::AppExecFwk::ElementName elementName;
206 AVSessionService* avSessionService_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
207 ASSERT_TRUE(avSessionService_ != nullptr);
208 elementName.SetBundleName("test.ohos.avsession");
209 elementName.SetAbilityName("test.ability");
210 OHOS::sptr <AVSessionItem> item =
211 avSessionService_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
212 ASSERT_TRUE(item != nullptr);
213 auto uid = AVSessionUsersManager::GetInstance().GetCurrentUserId();
214 item->SetPid(getpid());
215 item->SetUid(uid);
216 std::string sessionId = item->GetDescriptor().sessionId_;
217 SessionStack sessionStack;
218 sessionStack.AddSession(getpid(), elementName.GetAbilityName(), item);
219 auto ret = sessionStack.UidHasSession(-1);
220 EXPECT_EQ(ret, false);
221 ret = sessionStack.UidHasSession(uid);
222 EXPECT_EQ(ret, true);
223
224 avSessionService_->HandleSessionRelease(sessionId);
225 sessionStack.sessions_.clear();
226 }
227
228 /**
229 * @tc.name: GetSessionByUid001
230 * @tc.desc: verifying session stack get session by uid
231 * @tc.type: FUNC
232 */
233 HWTEST_F(SessionStackTest, GetSessionByUid001, TestSize.Level0)
234 {
235 OHOS::AppExecFwk::ElementName elementName;
236 AVSessionService* avSessionService_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
237 ASSERT_TRUE(avSessionService_ != nullptr);
238 elementName.SetBundleName("test.ohos.avsession");
239 elementName.SetAbilityName("test.ability");
240 OHOS::sptr <AVSessionItem> item =
241 avSessionService_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
242 ASSERT_TRUE(item != nullptr);
243 auto uid = AVSessionUsersManager::GetInstance().GetCurrentUserId();
244 item->SetPid(getpid());
245 item->SetUid(uid);
246 std::string sessionId = item->GetDescriptor().sessionId_;
247 SessionStack sessionStack;
248 sessionStack.AddSession(getpid(), elementName.GetAbilityName(), item);
249 auto ret = sessionStack.GetSessionByUid(-1);
250 EXPECT_EQ(ret, nullptr);
251
252 avSessionService_->HandleSessionRelease(sessionId);
253 sessionStack.sessions_.clear();
254 }
255 } //AVSession
256 } //OHOS