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 <gtest/gtest.h>
17 #include "avsession_log.h"
18 #include "iservice_registry.h"
19 #include "avmedia_description.h"
20 #include "av_file_descriptor.h"
21 #include "system_ability_definition.h"
22 #include "avsession_callback_proxy.h"
23
24 using namespace OHOS::AVSession;
25
26 static std::string g_errLog;
27
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)28 static void MyLogCallback(const LogType type, const LogLevel level,
29 const unsigned int domain, const char *tag, const char *msg)
30 {
31 g_errLog = msg;
32 }
33
34 class AVSessionCallbackProxyTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40
41 OHOS::sptr<AVSessionCallbackProxy> aVSessionCallbackProxy;
42 };
43
SetUpTestCase()44 void AVSessionCallbackProxyTest::SetUpTestCase()
45 {
46 }
47
TearDownTestCase()48 void AVSessionCallbackProxyTest::TearDownTestCase()
49 {
50 }
51
SetUp()52 void AVSessionCallbackProxyTest::SetUp()
53 {
54 auto mgr = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
55 if (mgr == nullptr) {
56 SLOGI("failed to get sa mgr");
57 return;
58 }
59 auto object = mgr->GetSystemAbility(OHOS::AVSESSION_SERVICE_ID);
60 if (object == nullptr) {
61 SLOGI("failed to get service");
62 return;
63 }
64 aVSessionCallbackProxy = OHOS::iface_cast<AVSessionCallbackProxy>(object);
65 }
66
TearDown()67 void AVSessionCallbackProxyTest::TearDown()
68 {
69 }
70
71 /**
72 * @tc.name: OnAVCallAnswer001
73 * @tc.desc: Test OnAVCallAnswer
74 * @tc.type: FUNC
75 */
76 static HWTEST_F(AVSessionCallbackProxyTest, OnAVCallAnswer001, testing::ext::TestSize.Level1)
77 {
78 SLOGI("OnAVCallAnswer001, start");
79 LOG_SetCallback(MyLogCallback);
80 aVSessionCallbackProxy->OnAVCallAnswer();
81 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
82 SLOGI("OnAVCallAnswer001, end");
83 }
84
85 /**
86 * @tc.name: OnAVCallHangUp001
87 * @tc.desc: Test OnAVCallHangUp
88 * @tc.type: FUNC
89 */
90 static HWTEST_F(AVSessionCallbackProxyTest, OnAVCallHangUp001, testing::ext::TestSize.Level1)
91 {
92 SLOGI("OnAVCallHangUp001, start");
93 LOG_SetCallback(MyLogCallback);
94 aVSessionCallbackProxy->OnAVCallHangUp();
95 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
96 SLOGI("OnAVCallHangUp001, end");
97 }
98
99 /**
100 * @tc.name: OnAVCallToggleCallMute001
101 * @tc.desc: Test OnAVCallToggleCallMute
102 * @tc.type: FUNC
103 */
104 static HWTEST_F(AVSessionCallbackProxyTest, OnAVCallToggleCallMute001, testing::ext::TestSize.Level1)
105 {
106 SLOGI("OnAVCallToggleCallMute001, start");
107 LOG_SetCallback(MyLogCallback);
108 aVSessionCallbackProxy->OnAVCallToggleCallMute();
109 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
110 SLOGI("OnAVCallToggleCallMute001, end");
111 }
112
113 /**
114 * @tc.name: OnPlay001
115 * @tc.desc: Test OnPlay
116 * @tc.type: FUNC
117 */
118 static HWTEST_F(AVSessionCallbackProxyTest, OnPlay001, testing::ext::TestSize.Level1)
119 {
120 SLOGI("OnPlay001, start");
121 LOG_SetCallback(MyLogCallback);
122 aVSessionCallbackProxy->OnPlay();
123 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
124 SLOGI("OnPlay001, end");
125 }
126
127 /**
128 * @tc.name: OnPause001
129 * @tc.desc: Test OnPause
130 * @tc.type: FUNC
131 */
132 static HWTEST_F(AVSessionCallbackProxyTest, OnPause001, testing::ext::TestSize.Level1)
133 {
134 SLOGI("OnPause001, start");
135 LOG_SetCallback(MyLogCallback);
136 aVSessionCallbackProxy->OnPause();
137 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
138 SLOGI("OnPause001, end");
139 }
140
141 /**
142 * @tc.name: OnStop001
143 * @tc.desc: Test OnStop
144 * @tc.type: FUNC
145 */
146 static HWTEST_F(AVSessionCallbackProxyTest, OnStop001, testing::ext::TestSize.Level1)
147 {
148 SLOGI("OnStop001, start");
149 LOG_SetCallback(MyLogCallback);
150 aVSessionCallbackProxy->OnStop();
151 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
152 SLOGI("OnStop001, end");
153 }
154
155 /**
156 * @tc.name: OnPlayNext001
157 * @tc.desc: Test OnPlayNext
158 * @tc.type: FUNC
159 */
160 static HWTEST_F(AVSessionCallbackProxyTest, OnPlayNext001, testing::ext::TestSize.Level1)
161 {
162 SLOGI("OnPlayNext001, start");
163 LOG_SetCallback(MyLogCallback);
164 aVSessionCallbackProxy->OnPlayNext();
165 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
166 SLOGI("OnPlayNext001, end");
167 }
168
169 /**
170 * @tc.name: OnPlayPrevious001
171 * @tc.desc: Test OnPlayPrevious
172 * @tc.type: FUNC
173 */
174 static HWTEST_F(AVSessionCallbackProxyTest, OnPlayPrevious001, testing::ext::TestSize.Level1)
175 {
176 SLOGI("OnPlayPrevious001, start");
177 LOG_SetCallback(MyLogCallback);
178 aVSessionCallbackProxy->OnPlayPrevious();
179 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
180 SLOGI("OnPlayPrevious001, end");
181 }
182
183 /**
184 * @tc.name: OnFastForward001
185 * @tc.desc: Test OnFastForward
186 * @tc.type: FUNC
187 */
188 static HWTEST_F(AVSessionCallbackProxyTest, OnFastForward001, testing::ext::TestSize.Level1)
189 {
190 SLOGI("OnFastForward001, start");
191 LOG_SetCallback(MyLogCallback);
192 int64_t time = 0;
193 aVSessionCallbackProxy->OnFastForward(time);
194 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
195 SLOGI("OnFastForward001, end");
196 }
197
198 /**
199 * @tc.name: OnRewind001
200 * @tc.desc: Test OnRewind
201 * @tc.type: FUNC
202 */
203 static HWTEST_F(AVSessionCallbackProxyTest, OnRewind001, testing::ext::TestSize.Level1)
204 {
205 SLOGI("OnRewind001, start");
206 LOG_SetCallback(MyLogCallback);
207 int64_t time = 0;
208 aVSessionCallbackProxy->OnRewind(time);
209 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
210 SLOGI("OnRewind001, end");
211 }
212
213 /**
214 * @tc.name: OnSeek001
215 * @tc.desc: Test OnSeek
216 * @tc.type: FUNC
217 */
218 static HWTEST_F(AVSessionCallbackProxyTest, OnSeek001, testing::ext::TestSize.Level1)
219 {
220 SLOGI("OnSeek001, start");
221 LOG_SetCallback(MyLogCallback);
222 int64_t time = 0;
223 aVSessionCallbackProxy->OnSeek(time);
224 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
225 SLOGI("OnSeek001, end");
226 }
227
228 /**
229 * @tc.name: OnSeek001
230 * @tc.desc: Test OnSetSpeed
231 * @tc.type: FUNC
232 */
233 static HWTEST_F(AVSessionCallbackProxyTest, OnSetSpeed001, testing::ext::TestSize.Level1)
234 {
235 SLOGI("OnSetSpeed001, start");
236 LOG_SetCallback(MyLogCallback);
237 double speed = 0;
238 aVSessionCallbackProxy->OnSetSpeed(speed);
239 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
240 SLOGI("OnSetSpeed001, end");
241 }
242
243 /**
244 * @tc.name: OnSetLoopMode001
245 * @tc.desc: Test OnSetLoopMode
246 * @tc.type: FUNC
247 */
248 static HWTEST_F(AVSessionCallbackProxyTest, OnSetLoopMode001, testing::ext::TestSize.Level1)
249 {
250 SLOGI("OnSetLoopMode001, start");
251 LOG_SetCallback(MyLogCallback);
252 int32_t loopMode = 0;
253 aVSessionCallbackProxy->OnSetLoopMode(loopMode);
254 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
255 SLOGI("OnSetLoopMode001, end");
256 }
257
258 /**
259 * @tc.name: OnSetTargetLoopMode001
260 * @tc.desc: Test OnSetTargetLoopMode
261 * @tc.type: FUNC
262 */
263 static HWTEST_F(AVSessionCallbackProxyTest, OnSetTargetLoopMode001, testing::ext::TestSize.Level1)
264 {
265 SLOGI("OnSetTargetLoopMode001, start");
266 LOG_SetCallback(MyLogCallback);
267 int32_t targetLoopMode = 0;
268 aVSessionCallbackProxy->OnSetTargetLoopMode(targetLoopMode);
269 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
270 SLOGI("OnSetTargetLoopMode001, end");
271 }
272
273 /**
274 * @tc.name: OnToggleFavorite001
275 * @tc.desc: Test OnToggleFavorite
276 * @tc.type: FUNC
277 */
278 static HWTEST_F(AVSessionCallbackProxyTest, OnToggleFavorite001, testing::ext::TestSize.Level1)
279 {
280 SLOGI("OnToggleFavorite001, start");
281 LOG_SetCallback(MyLogCallback);
282 std::string mediaId = "mediaId";
283 aVSessionCallbackProxy->OnToggleFavorite(mediaId);
284 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
285 SLOGI("OnToggleFavorite001, end");
286 }
287
288 /**
289 * @tc.name: OnMediaKeyEvent001
290 * @tc.desc: Test OnMediaKeyEvent
291 * @tc.type: FUNC
292 */
293 static HWTEST_F(AVSessionCallbackProxyTest, OnMediaKeyEvent001, testing::ext::TestSize.Level1)
294 {
295 SLOGI("OnMediaKeyEvent001, start");
296 LOG_SetCallback(MyLogCallback);
297 auto keyEvent = OHOS::MMI::KeyEvent::Create();
298 aVSessionCallbackProxy->OnMediaKeyEvent(*keyEvent);
299 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
300 SLOGI("OnMediaKeyEvent001, end");
301 }
302
303 /**
304 * @tc.name: OnOutputDeviceChange001
305 * @tc.desc: Test OnOutputDeviceChange
306 * @tc.type: FUNC
307 */
308 static HWTEST_F(AVSessionCallbackProxyTest, OnOutputDeviceChange001, testing::ext::TestSize.Level1)
309 {
310 SLOGI("OnOutputDeviceChange001, start");
311 LOG_SetCallback(MyLogCallback);
312 int32_t connectionState = 0;
313 OutputDeviceInfo outputDeviceInfo;
314 aVSessionCallbackProxy->OnOutputDeviceChange(connectionState, outputDeviceInfo);
315 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
316 SLOGI("OnOutputDeviceChange001, end");
317 }
318
319 /**
320 * @tc.name: OnCommonCommand001
321 * @tc.desc: Test OnCommonCommand
322 * @tc.type: FUNC
323 */
324 static HWTEST_F(AVSessionCallbackProxyTest, OnCommonCommand001, testing::ext::TestSize.Level1)
325 {
326 SLOGI("OnCommonCommand001, start");
327 LOG_SetCallback(MyLogCallback);
328 std::string commonCommand = "commonCommand";
329 OHOS::AAFwk::WantParams commandArgs;
330 aVSessionCallbackProxy->OnCommonCommand(commonCommand, commandArgs);
331 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
332 SLOGI("OnCommonCommand001, end");
333 }
334
335 /**
336 * @tc.name: OnSkipToQueueItem001
337 * @tc.desc: Test OnSkipToQueueItem
338 * @tc.type: FUNC
339 */
340 static HWTEST_F(AVSessionCallbackProxyTest, OnSkipToQueueItem001, testing::ext::TestSize.Level1)
341 {
342 SLOGI("OnSkipToQueueItem001, start");
343 LOG_SetCallback(MyLogCallback);
344 int32_t itemId = 0;
345 aVSessionCallbackProxy->OnSkipToQueueItem(itemId);
346 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
347 SLOGI("OnSkipToQueueItem001, end");
348 }
349
350 /**
351 * @tc.name: OnPlayFromAssetId001
352 * @tc.desc: Test OnPlayFromAssetId
353 * @tc.type: FUNC
354 */
355 static HWTEST_F(AVSessionCallbackProxyTest, OnPlayFromAssetId001, testing::ext::TestSize.Level1)
356 {
357 SLOGI("OnPlayFromAssetId001, start");
358 LOG_SetCallback(MyLogCallback);
359 int64_t assetId = 0;
360 aVSessionCallbackProxy->OnPlayFromAssetId(assetId);
361 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
362 SLOGI("OnPlayFromAssetId001, end");
363 }
364
365 /**
366 * @tc.name: OnCastDisplayChange001
367 * @tc.desc: Test OnCastDisplayChange
368 * @tc.type: FUNC
369 */
370 static HWTEST_F(AVSessionCallbackProxyTest, OnCastDisplayChange001, testing::ext::TestSize.Level1)
371 {
372 SLOGI("OnCastDisplayChange001, start");
373 LOG_SetCallback(MyLogCallback);
374 CastDisplayInfo castDisplayInfo;
375 aVSessionCallbackProxy->OnCastDisplayChange(castDisplayInfo);
376 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
377 SLOGI("OnCastDisplayChange001, end");
378 }