1 /*
2 * Copyright (c) 2022-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 <cmath>
17 #include <cstddef>
18 #include <memory>
19 #include <optional>
20 #include <string>
21 #include <utility>
22 #include <vector>
23
24 #include "gmock/gmock-actions.h"
25 #include "gtest/gtest.h"
26
27 #define private public
28 #define protected public
29 #include "test/mock/core/common/mock_theme_manager.h"
30 #include "test/mock/core/pipeline/mock_pipeline_context.h"
31 #include "test/mock/core/render/mock_media_player.h"
32 #include "test/mock/core/render/mock_render_context.h"
33
34 #include "base/geometry/ng/size_t.h"
35 #include "base/json/json_util.h"
36 #include "base/memory/ace_type.h"
37 #include "base/resource/internal_resource.h"
38 #include "core/common/ai/image_analyzer_mgr.h"
39 #include "core/components/common/layout/constants.h"
40 #include "core/components/video/video_theme.h"
41 #include "core/components/video/video_utils.h"
42 #include "core/components_ng/base/frame_node.h"
43 #include "core/components_ng/base/view_stack_processor.h"
44 #include "core/components_ng/layout/layout_algorithm.h"
45 #include "core/components_ng/pattern/image/image_layout_property.h"
46 #include "core/components_ng/pattern/linear_layout/linear_layout_property.h"
47 #include "core/components_ng/pattern/root/root_pattern.h"
48 #include "core/components_ng/pattern/text/text_layout_property.h"
49 #include "core/components_ng/pattern/text/text_pattern.h"
50 #include "core/components_ng/pattern/video/video_full_screen_node.h"
51 #include "core/components_ng/pattern/video/video_full_screen_pattern.h"
52 #include "core/components_ng/pattern/video/video_layout_algorithm.h"
53 #include "core/components_ng/pattern/video/video_layout_property.h"
54 #include "core/components_ng/pattern/video/video_model_ng.h"
55 #include "core/components_ng/pattern/video/video_node.h"
56 #include "core/components_ng/pattern/video/video_pattern.h"
57 #include "core/components_ng/pattern/video/video_styles.h"
58 #include "core/components_v2/inspector/inspector_constants.h"
59 #include "core/image/image_source_info.h"
60
61 using namespace testing;
62 using namespace testing::ext;
63
64 namespace OHOS::Ace::NG {
65 struct TestProperty {
66 std::optional<std::string> src;
67 std::optional<double> progressRate;
68 std::optional<std::string> posterUrl;
69 std::optional<bool> muted;
70 std::optional<bool> autoPlay;
71 std::optional<bool> controls;
72 std::optional<bool> loop;
73 std::optional<ImageFit> objectFit;
74 std::optional<RefPtr<VideoControllerV2>> videoController;
75 };
76 namespace {
77 constexpr double VIDEO_PROGRESS_RATE = 1.0;
78 constexpr bool MUTED_VALUE = false;
79 constexpr bool AUTO_PLAY = false;
80 constexpr bool CONTROL_VALUE = true;
81 constexpr bool LOOP_VALUE = false;
82 const ImageFit VIDEO_IMAGE_FIT = ImageFit::COVER;
83 const std::string VIDEO_SRC = "common/video.mp4";
84 const std::string VIDEO_POSTER_URL = "common/img2.png";
85 const std::string VIDEO_START_EVENT = "start";
86 const std::string VIDEO_PAUSE_EVENT = "pause";
87 const std::string VIDEO_FINISH_EVENT = "finish";
88 const std::string VIDEO_ERROR_EVENT = "error";
89 const std::string VIDEO_PREPARED_EVENT = "prepared";
90 const std::string VIDEO_SEEKING_EVENT = "seeking";
91 const std::string VIDEO_SEEKED_EVENT = "seeked";
92 const std::string VIDEO_UPDATE_EVENT = "update";
93 const std::string VIDEO_FULLSCREEN_EVENT = "fullScreen";
94 const std::string EXTRA_INFO_KEY = "extraInfo";
95 const std::string VIDEO_ERROR_ID = "";
96 const std::string VIDEO_CALLBACK_RESULT = "result_ok";
97 const std::string VIDEO_STOP_EVENT = "stop";
98 constexpr float MAX_WIDTH = 400.0f;
99 constexpr float MAX_HEIGHT = 400.0f;
100 constexpr float VIDEO_WIDTH = 300.0f;
101 constexpr float VIDEO_HEIGHT = 300.0f;
102 constexpr float SCREEN_WIDTH_SMALL = 500.0f;
103 constexpr float SCREEN_HEIGHT_SMALL = 1000.0f;
104 constexpr float SCREEN_WIDTH_MEDIUM = 1000.0f;
105 constexpr float SCREEN_HEIGHT_MEDIUM = 2000.0f;
106 constexpr float SCREEN_WIDTH_LARGE = 1500.0f;
107 constexpr float SCREEN_HEIGHT_LARGE = 2500.0f;
108 const SizeF MAX_SIZE(MAX_WIDTH, MAX_HEIGHT);
109 const SizeF SCREEN_SIZE_SMALL(SCREEN_WIDTH_SMALL, SCREEN_HEIGHT_SMALL);
110 const SizeF SCREEN_SIZE_MEDIUM(SCREEN_WIDTH_MEDIUM, SCREEN_HEIGHT_MEDIUM);
111 const SizeF SCREEN_SIZE_LARGE(SCREEN_WIDTH_LARGE, SCREEN_HEIGHT_LARGE);
112 const SizeF VIDEO_SIZE(VIDEO_WIDTH, VIDEO_HEIGHT);
113 const SizeF LAYOUT_SIZE_RATIO_GREATER_THAN_1(MAX_WIDTH, VIDEO_HEIGHT);
114 const SizeF LAYOUT_SIZE_RATIO_LESS_THAN_1(VIDEO_WIDTH, MAX_HEIGHT);
115 const SizeF INVALID_SIZE(MAX_WIDTH, 0.0f);
116 TestProperty g_testProperty;
117 } // namespace
118
119 class VideoTestAddNg : public testing::Test {
120 public:
121 static void SetUpTestSuite();
122 static void TearDownTestSuite();
123 void SetUp();
TearDown()124 void TearDown() {}
125
126 protected:
127 static RefPtr<FrameNode> CreateVideoNode(TestProperty& g_testProperty);
128 };
129
SetUpTestSuite()130 void VideoTestAddNg::SetUpTestSuite()
131 {
132 g_testProperty.progressRate = VIDEO_PROGRESS_RATE;
133 g_testProperty.muted = MUTED_VALUE;
134 g_testProperty.autoPlay = AUTO_PLAY;
135 g_testProperty.controls = CONTROL_VALUE;
136 g_testProperty.loop = LOOP_VALUE;
137 g_testProperty.objectFit = VIDEO_IMAGE_FIT;
138 MockPipelineContext::SetUp();
139 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
140 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
141 MockPipelineContext::GetCurrent()->rootNode_ = FrameNode::CreateFrameNodeWithTree(
142 V2::ROOT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<RootPattern>());
143 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
144 }
145
TearDownTestSuite()146 void VideoTestAddNg::TearDownTestSuite()
147 {
148 MockPipelineContext::TearDown();
149 }
SetUp()150 void VideoTestAddNg::SetUp()
151 {
152 ViewStackProcessor::GetInstance()->ClearStack();
153 }
154
CreateVideoNode(TestProperty & g_testProperty)155 RefPtr<FrameNode> VideoTestAddNg::CreateVideoNode(TestProperty& g_testProperty)
156 {
157 if (g_testProperty.videoController.has_value()) {
158 VideoModelNG().Create(g_testProperty.videoController.value());
159 } else {
160 auto videoController = AceType::MakeRefPtr<VideoControllerV2>();
161 VideoModelNG().Create(videoController);
162 }
163 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
164 CHECK_NULL_RETURN(frameNode, nullptr);
165 auto videoPattern = AceType::DynamicCast<VideoPattern>(frameNode->GetPattern());
166 CHECK_NULL_RETURN(videoPattern, nullptr);
167 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(videoPattern->mediaPlayer_)), IsMediaPlayerValid())
168 .WillRepeatedly(Return(true));
169
170 if (g_testProperty.src.has_value()) {
171 VideoModelNG().SetSrc(g_testProperty.src.value(), "", "");
172 }
173 if (g_testProperty.progressRate.has_value()) {
174 VideoModelNG().SetProgressRate(g_testProperty.progressRate.value());
175 }
176 if (g_testProperty.posterUrl.has_value()) {
177 VideoModelNG().SetPosterSourceInfo(g_testProperty.posterUrl.value(), "", "");
178 }
179 if (g_testProperty.muted.has_value()) {
180 VideoModelNG().SetMuted(g_testProperty.muted.value());
181 }
182 if (g_testProperty.autoPlay.has_value()) {
183 VideoModelNG().SetAutoPlay(g_testProperty.autoPlay.value());
184 }
185 if (g_testProperty.controls.has_value()) {
186 VideoModelNG().SetControls(g_testProperty.controls.value());
187 }
188 if (g_testProperty.loop.has_value()) {
189 VideoModelNG().SetLoop(g_testProperty.loop.value());
190 }
191 if (g_testProperty.objectFit.has_value()) {
192 VideoModelNG().SetObjectFit(g_testProperty.objectFit.value());
193 }
194
195 auto element = ViewStackProcessor::GetInstance()->GetMainFrameNode();
196 return AceType::Claim(element);
197 }
198
199 /**
200 * @tc.name: VideoPropertyTest001
201 * @tc.desc: Create Vdeo, and set its properties.
202 * @tc.type: FUNC
203 */
204 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest001, TestSize.Level1)
205 {
206 auto themeManager1 = AceType::MakeRefPtr<MockThemeManager>();
207 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager1);
208 EXPECT_CALL(*themeManager1, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
209 /**
210 * @tc.steps: step1. Create Video
211 * @tc.expected: step1. Create Video successfully
212 */
213 auto frameNode = CreateVideoNode(g_testProperty);
214 ASSERT_TRUE(frameNode);
215 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
216 auto pattern = frameNode->GetPattern<VideoPattern>();
217 ASSERT_TRUE(pattern);
218
219 /**
220 * @tc.steps: step2. Prepare the childNode & videoEvent
221 */
222 auto controlBar = frameNode->GetChildAtIndex(2);
223 ASSERT_TRUE(controlBar);
224
225 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
226 ASSERT_TRUE(playBtn);
227 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
228 ASSERT_TRUE(playBtnGestureEventHub);
229
230 // set videoEvent
231 auto videoEventHub = frameNode->GetEventHub<VideoEventHub>();
232 ASSERT_TRUE(videoEventHub);
233 std::string startCheck;
__anon57d7258b0202(const std::string& ) 234 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
235 std::string pauseCheck;
__anon57d7258b0302(const std::string& ) 236 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
237 std::string finishCheck;
__anon57d7258b0402(const std::string& ) 238 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
239 std::string stopCheck;
__anon57d7258b0502(const std::string& ) 240 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
241 videoEventHub->SetOnStart(std::move(onStart));
242 videoEventHub->SetOnPause(std::move(onPause));
243 videoEventHub->SetOnFinish(std::move(onFinish));
244 videoEventHub->SetOnStop(std::move(onStop));
245
246 /**
247 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
248 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern->Pause()
249 */
250 pattern->OnPlayerStatus(PlaybackStatus::STARTED);
251 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
252 // will call pattern->Pause()
253 EXPECT_TRUE(pattern->isPlaying_);
254 // case1: MediaPlayer is invalid
255 auto flag = playBtnGestureEventHub->ActClick();
256 EXPECT_TRUE(flag);
257
258 /**
259 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
260 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
261 */
262 // case1: MediaPlayer is invalid
263 pattern->OnPlayerStatus(PlaybackStatus::PAUSED);
264 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
265
266 /**
267 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
268 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
269 */
270 pattern->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
271 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
272 auto videoLayoutProperty = pattern->GetLayoutProperty<VideoLayoutProperty>();
273 videoLayoutProperty->UpdateControls(false);
274 pattern->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
275 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
276 pattern->OnPlayerStatus(PlaybackStatus::ERROR);
277 pattern->OnPlayerStatus(PlaybackStatus::IDLE);
278 pattern->OnPlayerStatus(PlaybackStatus::PREPARED);
279 pattern->OnPlayerStatus(PlaybackStatus::PAUSED);
280 pattern->OnPlayerStatus(PlaybackStatus::STOPPED);
281 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
282 pattern->OnPlayerStatus(PlaybackStatus::NONE);
283 }
284
285 /**
286 * @tc.name: VideoPropertyTest002
287 * @tc.desc: Create Vdeo, and set its properties.
288 * @tc.type: FUNC
289 */
290 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest002, TestSize.Level1)
291 {
292 auto themeManager2 = AceType::MakeRefPtr<MockThemeManager>();
293 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager2);
294 EXPECT_CALL(*themeManager2, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
295 /**
296 * @tc.steps: step1. Create Video
297 * @tc.expected: step1. Create Video successfully
298 */
299 auto frameNode = CreateVideoNode(g_testProperty);
300 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
301 auto pattern2 = frameNode->GetPattern<VideoPattern>();
302
303 /**
304 * @tc.steps: step2. Prepare the childNode & videoEvent
305 */
306 auto controlBar = frameNode->GetChildAtIndex(2);
307 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
308 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
309
310 // set videoEvent
311 auto videoEventHub2 = frameNode->GetEventHub<VideoEventHub>();
312 ASSERT_TRUE(videoEventHub2);
313 std::string startCheck;
__anon57d7258b0602(const std::string& ) 314 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
315 std::string pauseCheck;
__anon57d7258b0702(const std::string& ) 316 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
317 std::string finishCheck;
__anon57d7258b0802(const std::string& ) 318 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
319 std::string stopCheck;
__anon57d7258b0902(const std::string& ) 320 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
321 videoEventHub2->SetOnStart(std::move(onStart));
322 videoEventHub2->SetOnPause(std::move(onPause));
323 videoEventHub2->SetOnFinish(std::move(onFinish));
324 videoEventHub2->SetOnStop(std::move(onStop));
325
326 /**
327 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
328 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern2->Pause()
329 */
330 pattern2->OnPlayerStatus(PlaybackStatus::STARTED);
331 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
332 // will call pattern2->Pause()
333 EXPECT_TRUE(pattern2->isPlaying_);
334 // case1: MediaPlayer is invalid
335 auto flag = playBtnGestureEventHub->ActClick();
336 EXPECT_TRUE(flag);
337
338 /**
339 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
340 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
341 */
342 // case1: MediaPlayer is valid
343 pauseCheck.clear();
344 pattern2->OnPlayerStatus(PlaybackStatus::PAUSED);
345 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
346
347 /**
348 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
349 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
350 */
351 pattern2->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
352 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
353 auto videoLayoutProperty = pattern2->GetLayoutProperty<VideoLayoutProperty>();
354 videoLayoutProperty->UpdateControls(false);
355 pattern2->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
356 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
357 pattern2->OnPlayerStatus(PlaybackStatus::ERROR);
358 pattern2->OnPlayerStatus(PlaybackStatus::IDLE);
359 pattern2->OnPlayerStatus(PlaybackStatus::PREPARED);
360 pattern2->OnPlayerStatus(PlaybackStatus::PAUSED);
361 pattern2->OnPlayerStatus(PlaybackStatus::STOPPED);
362 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
363 pattern2->OnPlayerStatus(PlaybackStatus::NONE);
364 }
365
366 /**
367 * @tc.name: VideoPropertyTest003
368 * @tc.desc: Create Vdeo, and set its properties.
369 * @tc.type: FUNC
370 */
371 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest003, TestSize.Level1)
372 {
373 auto themeManager3 = AceType::MakeRefPtr<MockThemeManager>();
374 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager3);
375 EXPECT_CALL(*themeManager3, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
376 /**
377 * @tc.steps: step1. Create Video
378 * @tc.expected: step1. Create Video successfully
379 */
380 auto frameNode = CreateVideoNode(g_testProperty);
381 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
382 auto pattern3 = frameNode->GetPattern<VideoPattern>();
383
384 /**
385 * @tc.steps: step2. Prepare the childNode & videoEvent
386 */
387 auto controlBar = frameNode->GetChildAtIndex(2);
388 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
389 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
390
391 // set videoEvent
392 auto videoEventHub3 = frameNode->GetEventHub<VideoEventHub>();
393 std::string startCheck;
__anon57d7258b0a02(const std::string& ) 394 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
395 std::string pauseCheck;
__anon57d7258b0b02(const std::string& ) 396 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
397 std::string finishCheck;
__anon57d7258b0c02(const std::string& ) 398 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
399 std::string stopCheck;
__anon57d7258b0d02(const std::string& ) 400 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
401 videoEventHub3->SetOnStart(std::move(onStart));
402 videoEventHub3->SetOnPause(std::move(onPause));
403 videoEventHub3->SetOnFinish(std::move(onFinish));
404 videoEventHub3->SetOnStop(std::move(onStop));
405
406 /**
407 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
408 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern3->Pause()
409 */
410 pattern3->OnPlayerStatus(PlaybackStatus::STARTED);
411 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
412 // will call pattern3->Pause()
413 EXPECT_TRUE(pattern3->isPlaying_);
414 // case1: MediaPlayer is valid & isPlaying = true
415 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(pattern3->mediaPlayer_)),
416 Pause()).Times(1).WillOnce(Return(0));
417 auto flag = playBtnGestureEventHub->ActClick();
418 EXPECT_TRUE(flag);
419
420 /**
421 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
422 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
423 */
424 // case1: MediaPlayer is invalid
425 pattern3->OnPlayerStatus(PlaybackStatus::PAUSED);
426 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
427
428 /**
429 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
430 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
431 */
432 pattern3->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
433 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
434 auto videoLayoutProperty = pattern3->GetLayoutProperty<VideoLayoutProperty>();
435 videoLayoutProperty->UpdateControls(false);
436 pattern3->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
437 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
438 pattern3->OnPlayerStatus(PlaybackStatus::ERROR);
439 pattern3->OnPlayerStatus(PlaybackStatus::IDLE);
440 pattern3->OnPlayerStatus(PlaybackStatus::PREPARED);
441 pattern3->OnPlayerStatus(PlaybackStatus::PAUSED);
442 pattern3->OnPlayerStatus(PlaybackStatus::STOPPED);
443 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
444 pattern3->OnPlayerStatus(PlaybackStatus::NONE);
445 }
446
447 /**
448 * @tc.name: VideoPropertyTest004
449 * @tc.desc: Create Vdeo, and set its properties.
450 * @tc.type: FUNC
451 */
452 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest004, TestSize.Level1)
453 {
454 auto themeManager4 = AceType::MakeRefPtr<MockThemeManager>();
455 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager4);
456 EXPECT_CALL(*themeManager4, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
457 /**
458 * @tc.steps: step1. Create Video
459 * @tc.expected: step1. Create Video successfully
460 */
461 auto frameNode = CreateVideoNode(g_testProperty);
462 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
463 auto pattern4 = frameNode->GetPattern<VideoPattern>();
464
465 /**
466 * @tc.steps: step2. Prepare the childNode & videoEvent
467 */
468 auto controlBar = frameNode->GetChildAtIndex(2);
469 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
470 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
471
472 // set videoEvent
473 auto videoEventHub4 = frameNode->GetEventHub<VideoEventHub>();
474 std::string startCheck;
__anon57d7258b0e02(const std::string& ) 475 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
476 std::string pauseCheck;
__anon57d7258b0f02(const std::string& ) 477 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
478 std::string finishCheck;
__anon57d7258b1002(const std::string& ) 479 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
480 std::string stopCheck;
__anon57d7258b1102(const std::string& ) 481 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
482 videoEventHub4->SetOnStart(std::move(onStart));
483 videoEventHub4->SetOnPause(std::move(onPause));
484 videoEventHub4->SetOnFinish(std::move(onFinish));
485 videoEventHub4->SetOnStop(std::move(onStop));
486
487 /**
488 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
489 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern4->Pause()
490 */
491 pattern4->OnPlayerStatus(PlaybackStatus::STARTED);
492 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
493 // will call pattern4->Pause()
494 EXPECT_TRUE(pattern4->isPlaying_);
495 // case1: MediaPlayer is valid & isPlaying = true
496 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(pattern4->mediaPlayer_)),
497 Pause()).Times(1).WillOnce(Return(0));
498 auto flag = playBtnGestureEventHub->ActClick();
499 EXPECT_TRUE(flag);
500
501 /**
502 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
503 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
504 */
505 // case1: MediaPlayer is valid
506 pauseCheck.clear();
507 pattern4->OnPlayerStatus(PlaybackStatus::PAUSED);
508 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
509
510 /**
511 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
512 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
513 */
514 pattern4->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
515 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
516 auto videoLayoutProperty = pattern4->GetLayoutProperty<VideoLayoutProperty>();
517 videoLayoutProperty->UpdateControls(false);
518 pattern4->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
519 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
520 pattern4->OnPlayerStatus(PlaybackStatus::ERROR);
521 pattern4->OnPlayerStatus(PlaybackStatus::IDLE);
522 pattern4->OnPlayerStatus(PlaybackStatus::PREPARED);
523 pattern4->OnPlayerStatus(PlaybackStatus::PAUSED);
524 pattern4->OnPlayerStatus(PlaybackStatus::STOPPED);
525 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
526 pattern4->OnPlayerStatus(PlaybackStatus::NONE);
527 }
528
529 /**
530 * @tc.name: VideoPropertyTest005
531 * @tc.desc: Create Vdeo, and set its properties.
532 * @tc.type: FUNC
533 */
534 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest005, TestSize.Level1)
535 {
536 auto themeManager5 = AceType::MakeRefPtr<MockThemeManager>();
537 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager5);
538 EXPECT_CALL(*themeManager5, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
539 /**
540 * @tc.steps: step1. Create Video
541 * @tc.expected: step1. Create Video successfully
542 */
543 auto frameNode = CreateVideoNode(g_testProperty);
544 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
545 auto pattern5 = frameNode->GetPattern<VideoPattern>();
546
547 /**
548 * @tc.steps: step2. Prepare the childNode & videoEvent
549 */
550 auto controlBar = frameNode->GetChildAtIndex(2);
551 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
552 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
553
554 // set videoEvent
555 auto videoEventHub5 = frameNode->GetEventHub<VideoEventHub>();
556 ASSERT_TRUE(videoEventHub5);
557 std::string startCheck;
__anon57d7258b1202(const std::string& ) 558 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
559 std::string pauseCheck;
__anon57d7258b1302(const std::string& ) 560 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
561 std::string finishCheck;
__anon57d7258b1402(const std::string& ) 562 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
563 std::string stopCheck;
__anon57d7258b1502(const std::string& ) 564 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
565 videoEventHub5->SetOnStart(std::move(onStart));
566 videoEventHub5->SetOnPause(std::move(onPause));
567 videoEventHub5->SetOnFinish(std::move(onFinish));
568 videoEventHub5->SetOnStop(std::move(onStop));
569
570 /**
571 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
572 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern5->Pause()
573 */
574 pattern5->OnPlayerStatus(PlaybackStatus::STARTED);
575 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
576 // will call pattern5->Pause()
577 EXPECT_TRUE(pattern5->isPlaying_);
578
579 // case1: MediaPlayer is valid & isPlaying = false
580 pattern5->isPlaying_ = false;
581 auto flag = playBtnGestureEventHub->ActClick();
582 EXPECT_TRUE(flag);
583
584 /**
585 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
586 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
587 */
588 // case1: MediaPlayer is invalid
589 pattern5->OnPlayerStatus(PlaybackStatus::PAUSED);
590 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
591
592 /**
593 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
594 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
595 */
596 pattern5->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
597 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
598 auto videoLayoutProperty = pattern5->GetLayoutProperty<VideoLayoutProperty>();
599 videoLayoutProperty->UpdateControls(false);
600 pattern5->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
601 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
602 pattern5->OnPlayerStatus(PlaybackStatus::ERROR);
603 pattern5->OnPlayerStatus(PlaybackStatus::IDLE);
604 pattern5->OnPlayerStatus(PlaybackStatus::PREPARED);
605 pattern5->OnPlayerStatus(PlaybackStatus::PAUSED);
606 pattern5->OnPlayerStatus(PlaybackStatus::STOPPED);
607 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
608 pattern5->OnPlayerStatus(PlaybackStatus::NONE);
609 }
610
611 /**
612 * @tc.name: VideoPropertyTest006
613 * @tc.desc: Create Vdeo, and set its properties.
614 * @tc.type: FUNC
615 */
616 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest006, TestSize.Level1)
617 {
618 auto themeManager6 = AceType::MakeRefPtr<MockThemeManager>();
619 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager6);
620 EXPECT_CALL(*themeManager6, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
621
622 /**
623 * @tc.steps: step1. Create Video
624 * @tc.expected: step1. Create Video successfully
625 */
626 auto frameNode = CreateVideoNode(g_testProperty);
627 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
628 auto pattern6 = frameNode->GetPattern<VideoPattern>();
629
630 /**
631 * @tc.steps: step2. Prepare the childNode & videoEvent
632 */
633 auto controlBar = frameNode->GetChildAtIndex(2);
634 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
635 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
636
637 // set videoEvent
638 auto videoEventHub6 = frameNode->GetEventHub<VideoEventHub>();
639 ASSERT_TRUE(videoEventHub6);
640 std::string startCheck;
__anon57d7258b1602(const std::string& ) 641 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
642 std::string pauseCheck;
__anon57d7258b1702(const std::string& ) 643 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
644 std::string finishCheck;
__anon57d7258b1802(const std::string& ) 645 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
646 std::string stopCheck;
__anon57d7258b1902(const std::string& ) 647 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
648 videoEventHub6->SetOnStart(std::move(onStart));
649 videoEventHub6->SetOnPause(std::move(onPause));
650 videoEventHub6->SetOnFinish(std::move(onFinish));
651 videoEventHub6->SetOnStop(std::move(onStop));
652
653 /**
654 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
655 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern6->Pause()
656 */
657 pattern6->OnPlayerStatus(PlaybackStatus::STARTED);
658 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
659 // will call pattern6->Pause()
660 EXPECT_TRUE(pattern6->isPlaying_);
661
662 // case1: MediaPlayer is valid & isPlaying = false
663 pattern6->isPlaying_ = false;
664 auto flag = playBtnGestureEventHub->ActClick();
665 EXPECT_TRUE(flag);
666
667 /**
668 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
669 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
670 */
671 // case1: MediaPlayer is valid
672 pauseCheck.clear();
673 pattern6->OnPlayerStatus(PlaybackStatus::PAUSED);
674 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
675
676 /**
677 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
678 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
679 */
680 pattern6->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
681 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
682 auto videoLayoutProperty = pattern6->GetLayoutProperty<VideoLayoutProperty>();
683 videoLayoutProperty->UpdateControls(false);
684 pattern6->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
685 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
686 pattern6->OnPlayerStatus(PlaybackStatus::ERROR);
687 pattern6->OnPlayerStatus(PlaybackStatus::IDLE);
688 pattern6->OnPlayerStatus(PlaybackStatus::PREPARED);
689 pattern6->OnPlayerStatus(PlaybackStatus::PAUSED);
690 pattern6->OnPlayerStatus(PlaybackStatus::STOPPED);
691 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
692 pattern6->OnPlayerStatus(PlaybackStatus::NONE);
693 }
694
695 /**
696 * @tc.name: VideoPropertyTest007
697 * @tc.desc: Create Vdeo, and set its properties.
698 * @tc.type: FUNC
699 */
700 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest007, TestSize.Level1)
701 {
702 auto themeManager7 = AceType::MakeRefPtr<MockThemeManager>();
703 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager7);
704 EXPECT_CALL(*themeManager7, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
705 /**
706 * @tc.steps: step1. Create Video
707 * @tc.expected: step1. Create Video successfully
708 */
709 auto frameNode = CreateVideoNode(g_testProperty);
710 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
711 auto pattern7 = frameNode->GetPattern<VideoPattern>();
712
713 /**
714 * @tc.steps: step2. Prepare the childNode & videoEvent
715 */
716 auto controlBar = frameNode->GetChildAtIndex(2);
717 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
718 ASSERT_TRUE(playBtn);
719 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
720 ASSERT_TRUE(playBtnGestureEventHub);
721
722 // set videoEvent
723 auto videoEventHub7 = frameNode->GetEventHub<VideoEventHub>();
724 ASSERT_TRUE(videoEventHub7);
725 std::string startCheck;
__anon57d7258b1a02(const std::string& ) 726 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
727 std::string pauseCheck;
__anon57d7258b1b02(const std::string& ) 728 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
729 std::string finishCheck;
__anon57d7258b1c02(const std::string& ) 730 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
731 std::string stopCheck;
__anon57d7258b1d02(const std::string& ) 732 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
733 videoEventHub7->SetOnStart(std::move(onStart));
734 videoEventHub7->SetOnPause(std::move(onPause));
735 videoEventHub7->SetOnFinish(std::move(onFinish));
736 videoEventHub7->SetOnStop(std::move(onStop));
737
738 /**
739 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
740 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern7->Pause()
741 */
742 pattern7->OnPlayerStatus(PlaybackStatus::STARTED);
743 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
744 // will call pattern7->Pause()
745 EXPECT_TRUE(pattern7->isPlaying_);
746 // case1: MediaPlayer is invalid
747 auto flag = playBtnGestureEventHub->ActClick();
748 EXPECT_TRUE(flag);
749 // case2: MediaPlayer is valid & isPlaying = true
750 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(pattern7->mediaPlayer_)),
751 Pause()).Times(2).WillOnce(Return(0));
752 flag = playBtnGestureEventHub->ActClick();
753 EXPECT_TRUE(flag);
754 // case3: MediaPlayer is valid & isPlaying = false
755 pattern7->isPlaying_ = false;
756 flag = playBtnGestureEventHub->ActClick();
757 EXPECT_TRUE(flag);
758
759 /**
760 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
761 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
762 */
763 // case1: MediaPlayer is invalid
764 pattern7->OnPlayerStatus(PlaybackStatus::PAUSED);
765 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
766
767 // case1: MediaPlayer is valid
768 pauseCheck.clear();
769 pattern7->OnPlayerStatus(PlaybackStatus::PAUSED);
770 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
771
772 /**
773 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
774 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
775 */
776 pattern7->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
777 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
778 auto videoLayoutProperty = pattern7->GetLayoutProperty<VideoLayoutProperty>();
779 videoLayoutProperty->UpdateControls(false);
780 }
781
782 /**
783 * @tc.name: VideoPropertyTest008
784 * @tc.desc: Create Vdeo, and set its properties.
785 * @tc.type: FUNC
786 */
787 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest008, TestSize.Level1)
788 {
789 auto themeManager8 = AceType::MakeRefPtr<MockThemeManager>();
790 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager8);
791 EXPECT_CALL(*themeManager8, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
792 /**
793 * @tc.steps: step1. Create Video
794 * @tc.expected: step1. Create Video successfully
795 */
796 auto frameNode = CreateVideoNode(g_testProperty);
797 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
798 auto pattern8 = frameNode->GetPattern<VideoPattern>();
799
800 /**
801 * @tc.steps: step2. Prepare the childNode & videoEvent
802 */
803 auto controlBar = frameNode->GetChildAtIndex(2);
804 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
805 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
806
807 // set videoEvent
808 auto videoEventHub8 = frameNode->GetEventHub<VideoEventHub>();
809 std::string startCheck;
__anon57d7258b1e02(const std::string& ) 810 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
811 std::string pauseCheck;
__anon57d7258b1f02(const std::string& ) 812 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
813 std::string finishCheck;
__anon57d7258b2002(const std::string& ) 814 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
815 std::string stopCheck;
__anon57d7258b2102(const std::string& ) 816 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
817 videoEventHub8->SetOnStart(std::move(onStart));
818 videoEventHub8->SetOnPause(std::move(onPause));
819 videoEventHub8->SetOnFinish(std::move(onFinish));
820 videoEventHub8->SetOnStop(std::move(onStop));
821
822 /**
823 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
824 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern8->Pause()
825 */
826 pattern8->OnPlayerStatus(PlaybackStatus::STARTED);
827 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
828 // will call pattern8->Pause()
829 EXPECT_TRUE(pattern8->isPlaying_);
830 // case1: MediaPlayer is invalid
831 auto flag = playBtnGestureEventHub->ActClick();
832 EXPECT_TRUE(flag);
833 // case2: MediaPlayer is valid & isPlaying = true
834 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(pattern8->mediaPlayer_)),
835 Pause()).Times(1).WillOnce(Return(0));
836 // case3: MediaPlayer is valid & isPlaying = false
837 pattern8->isPlaying_ = false;
838 flag = playBtnGestureEventHub->ActClick();
839 EXPECT_TRUE(flag);
840
841 /**
842 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
843 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
844 */
845 // case1: MediaPlayer is invalid
846 pattern8->OnPlayerStatus(PlaybackStatus::PAUSED);
847 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
848
849 // case1: MediaPlayer is valid
850 pauseCheck.clear();
851 pattern8->OnPlayerStatus(PlaybackStatus::PAUSED);
852 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
853
854 /**
855 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
856 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
857 */
858 auto videoLayoutProperty = pattern8->GetLayoutProperty<VideoLayoutProperty>();
859 videoLayoutProperty->UpdateControls(false);
860 pattern8->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
861 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
862 pattern8->OnPlayerStatus(PlaybackStatus::ERROR);
863 pattern8->OnPlayerStatus(PlaybackStatus::IDLE);
864 pattern8->OnPlayerStatus(PlaybackStatus::PREPARED);
865 pattern8->OnPlayerStatus(PlaybackStatus::PAUSED);
866 pattern8->OnPlayerStatus(PlaybackStatus::STOPPED);
867 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
868 pattern8->OnPlayerStatus(PlaybackStatus::NONE);
869 }
870
871 /**
872 * @tc.name: VideoPropertyTest009
873 * @tc.desc: Create Vdeo, and set its properties.
874 * @tc.type: FUNC
875 */
876 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest009, TestSize.Level1)
877 {
878 auto themeManager9 = AceType::MakeRefPtr<MockThemeManager>();
879 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager9);
880 EXPECT_CALL(*themeManager9, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
881 /**
882 * @tc.steps: step1. Create Video
883 * @tc.expected: step1. Create Video successfully
884 */
885 auto frameNode = CreateVideoNode(g_testProperty);
886 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
887 auto pattern9 = frameNode->GetPattern<VideoPattern>();
888
889 /**
890 * @tc.steps: step2. Prepare the childNode & videoEvent
891 */
892 auto controlBar = frameNode->GetChildAtIndex(2);
893 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
894 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
895
896 // set videoEvent
897 auto videoEventHub9 = frameNode->GetEventHub<VideoEventHub>();
898 std::string startCheck;
__anon57d7258b2202(const std::string& ) 899 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
900 std::string pauseCheck;
__anon57d7258b2302(const std::string& ) 901 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
902 std::string finishCheck;
__anon57d7258b2402(const std::string& ) 903 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
904 std::string stopCheck;
__anon57d7258b2502(const std::string& ) 905 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
906 videoEventHub9->SetOnStart(std::move(onStart));
907 videoEventHub9->SetOnPause(std::move(onPause));
908 videoEventHub9->SetOnFinish(std::move(onFinish));
909 videoEventHub9->SetOnStop(std::move(onStop));
910
911 /**
912 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
913 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern9->Pause()
914 */
915 pattern9->OnPlayerStatus(PlaybackStatus::STARTED);
916 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
917 // will call pattern9->Pause()
918 EXPECT_TRUE(pattern9->isPlaying_);
919 // case1: MediaPlayer is invalid
920 auto flag = playBtnGestureEventHub->ActClick();
921 EXPECT_TRUE(flag);
922
923 /**
924 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
925 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
926 */
927 // case1: MediaPlayer is invalid
928 pattern9->OnPlayerStatus(PlaybackStatus::PAUSED);
929 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
930
931 /**
932 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
933 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
934 */
935 pattern9->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
936 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
937 auto videoLayoutProperty = pattern9->GetLayoutProperty<VideoLayoutProperty>();
938 videoLayoutProperty->UpdateControls(false);
939 }
940
941 /**
942 * @tc.name: VideoPropertyTest010
943 * @tc.desc: Create Vdeo, and set its properties.
944 * @tc.type: FUNC
945 */
946 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest010, TestSize.Level1)
947 {
948 auto themeManager10 = AceType::MakeRefPtr<MockThemeManager>();
949 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager10);
950 EXPECT_CALL(*themeManager10, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
951 /**
952 * @tc.steps: step1. Create Video
953 * @tc.expected: step1. Create Video successfully
954 */
955 auto frameNode = CreateVideoNode(g_testProperty);
956 ASSERT_TRUE(frameNode);
957 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
958 auto pattern10 = frameNode->GetPattern<VideoPattern>();
959 ASSERT_TRUE(pattern10);
960
961 /**
962 * @tc.steps: step2. Prepare the childNode & videoEvent
963 */
964 auto controlBar = frameNode->GetChildAtIndex(2);
965 ASSERT_TRUE(controlBar);
966
967 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
968 ASSERT_TRUE(playBtn);
969 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
970 ASSERT_TRUE(playBtnGestureEventHub);
971
972 // set videoEvent
973 auto videoEventHub10 = frameNode->GetEventHub<VideoEventHub>();
974 ASSERT_TRUE(videoEventHub10);
975 std::string startCheck;
__anon57d7258b2602(const std::string& ) 976 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
977 std::string pauseCheck;
__anon57d7258b2702(const std::string& ) 978 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
979 std::string finishCheck;
__anon57d7258b2802(const std::string& ) 980 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
981 std::string stopCheck;
__anon57d7258b2902(const std::string& ) 982 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
983 videoEventHub10->SetOnStart(std::move(onStart));
984 videoEventHub10->SetOnPause(std::move(onPause));
985 videoEventHub10->SetOnFinish(std::move(onFinish));
986 videoEventHub10->SetOnStop(std::move(onStop));
987
988 /**
989 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
990 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern10->Pause()
991 */
992 pattern10->OnPlayerStatus(PlaybackStatus::STARTED);
993 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
994 // will call pattern10->Pause()
995 EXPECT_TRUE(pattern10->isPlaying_);
996 // case1: MediaPlayer is invalid
997 auto flag = playBtnGestureEventHub->ActClick();
998 EXPECT_TRUE(flag);
999
1000 /**
1001 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1002 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1003 */
1004 // case1: MediaPlayer is valid
1005 pauseCheck.clear();
1006 pattern10->OnPlayerStatus(PlaybackStatus::PAUSED);
1007 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1008
1009 /**
1010 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1011 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1012 */
1013 pattern10->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
1014 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1015 auto videoLayoutProperty = pattern10->GetLayoutProperty<VideoLayoutProperty>();
1016 videoLayoutProperty->UpdateControls(false);
1017 }
1018
1019 /**
1020 * @tc.name: VideoPropertyTest011
1021 * @tc.desc: Create Vdeo, and set its properties.
1022 * @tc.type: FUNC
1023 */
1024 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest011, TestSize.Level1)
1025 {
1026 auto themeManager11 = AceType::MakeRefPtr<MockThemeManager>();
1027 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager11);
1028 EXPECT_CALL(*themeManager11, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1029 /**
1030 * @tc.steps: step1. Create Video
1031 * @tc.expected: step1. Create Video successfully
1032 */
1033 auto frameNode = CreateVideoNode(g_testProperty);
1034 ASSERT_TRUE(frameNode);
1035 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1036 auto pattern11 = frameNode->GetPattern<VideoPattern>();
1037 ASSERT_TRUE(pattern11);
1038
1039 /**
1040 * @tc.steps: step2. Prepare the childNode & videoEvent
1041 */
1042 auto controlBar = frameNode->GetChildAtIndex(2);
1043 ASSERT_TRUE(controlBar);
1044
1045 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1046 ASSERT_TRUE(playBtn);
1047 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1048 ASSERT_TRUE(playBtnGestureEventHub);
1049
1050 // set videoEvent
1051 auto videoEventHub11 = frameNode->GetEventHub<VideoEventHub>();
1052 ASSERT_TRUE(videoEventHub11);
1053 std::string startCheck;
__anon57d7258b2a02(const std::string& ) 1054 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1055 std::string pauseCheck;
__anon57d7258b2b02(const std::string& ) 1056 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1057 std::string finishCheck;
__anon57d7258b2c02(const std::string& ) 1058 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1059 std::string stopCheck;
__anon57d7258b2d02(const std::string& ) 1060 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1061 videoEventHub11->SetOnStart(std::move(onStart));
1062 videoEventHub11->SetOnPause(std::move(onPause));
1063 videoEventHub11->SetOnFinish(std::move(onFinish));
1064 videoEventHub11->SetOnStop(std::move(onStop));
1065
1066 /**
1067 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1068 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern11->Pause()
1069 */
1070 pattern11->OnPlayerStatus(PlaybackStatus::STARTED);
1071 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1072 // will call pattern11->Pause()
1073 EXPECT_TRUE(pattern11->isPlaying_);
1074 // case1: MediaPlayer is invalid
1075 auto flag = playBtnGestureEventHub->ActClick();
1076 EXPECT_TRUE(flag);
1077
1078 /**
1079 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1080 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1081 */
1082 // case1: MediaPlayer is invalid
1083 pattern11->OnPlayerStatus(PlaybackStatus::PAUSED);
1084 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1085
1086 /**
1087 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1088 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1089 */
1090 auto videoLayoutProperty = pattern11->GetLayoutProperty<VideoLayoutProperty>();
1091 videoLayoutProperty->UpdateControls(false);
1092 pattern11->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = false
1093 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1094 pattern11->OnPlayerStatus(PlaybackStatus::ERROR);
1095 pattern11->OnPlayerStatus(PlaybackStatus::IDLE);
1096 pattern11->OnPlayerStatus(PlaybackStatus::PREPARED);
1097 pattern11->OnPlayerStatus(PlaybackStatus::PAUSED);
1098 pattern11->OnPlayerStatus(PlaybackStatus::STOPPED);
1099 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
1100 pattern11->OnPlayerStatus(PlaybackStatus::NONE);
1101 }
1102
1103 /**
1104 * @tc.name: VideoPropertyTest012
1105 * @tc.desc: Create Vdeo, and set its properties.
1106 * @tc.type: FUNC
1107 */
1108 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest012, TestSize.Level1)
1109 {
1110 auto themeManager12 = AceType::MakeRefPtr<MockThemeManager>();
1111 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager12);
1112 EXPECT_CALL(*themeManager12, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1113 /**
1114 * @tc.steps: step1. Create Video
1115 * @tc.expected: step1. Create Video successfully
1116 */
1117 auto frameNode = CreateVideoNode(g_testProperty);
1118 ASSERT_TRUE(frameNode);
1119 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1120 auto pattern12 = frameNode->GetPattern<VideoPattern>();
1121 ASSERT_TRUE(pattern12);
1122
1123 /**
1124 * @tc.steps: step2. Prepare the childNode & videoEvent
1125 */
1126 auto controlBar = frameNode->GetChildAtIndex(2);
1127 ASSERT_TRUE(controlBar);
1128
1129 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1130 ASSERT_TRUE(playBtn);
1131 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1132 ASSERT_TRUE(playBtnGestureEventHub);
1133
1134 // set videoEvent
1135 auto videoEventHub12 = frameNode->GetEventHub<VideoEventHub>();
1136 ASSERT_TRUE(videoEventHub12);
1137 std::string startCheck;
__anon57d7258b2e02(const std::string& ) 1138 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1139 std::string pauseCheck;
__anon57d7258b2f02(const std::string& ) 1140 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1141 std::string finishCheck;
__anon57d7258b3002(const std::string& ) 1142 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1143 std::string stopCheck;
__anon57d7258b3102(const std::string& ) 1144 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1145 videoEventHub12->SetOnStart(std::move(onStart));
1146 videoEventHub12->SetOnPause(std::move(onPause));
1147 videoEventHub12->SetOnFinish(std::move(onFinish));
1148 videoEventHub12->SetOnStop(std::move(onStop));
1149
1150 /**
1151 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1152 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern12->Pause()
1153 */
1154 pattern12->OnPlayerStatus(PlaybackStatus::STARTED);
1155 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1156 // will call pattern12->Pause()
1157 EXPECT_TRUE(pattern12->isPlaying_);
1158 // case1: MediaPlayer is invalid
1159 auto flag = playBtnGestureEventHub->ActClick();
1160 EXPECT_TRUE(flag);
1161
1162 /**
1163 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1164 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1165 */
1166 // case1: MediaPlayer is valid
1167 pauseCheck.clear();
1168 pattern12->OnPlayerStatus(PlaybackStatus::PAUSED);
1169 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1170
1171 /**
1172 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1173 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1174 */
1175 auto videoLayoutProperty = pattern12->GetLayoutProperty<VideoLayoutProperty>();
1176 videoLayoutProperty->UpdateControls(false);
1177 pattern12->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = false
1178 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1179 pattern12->OnPlayerStatus(PlaybackStatus::ERROR);
1180 pattern12->OnPlayerStatus(PlaybackStatus::IDLE);
1181 pattern12->OnPlayerStatus(PlaybackStatus::PREPARED);
1182 pattern12->OnPlayerStatus(PlaybackStatus::PAUSED);
1183 pattern12->OnPlayerStatus(PlaybackStatus::STOPPED);
1184 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
1185 pattern12->OnPlayerStatus(PlaybackStatus::NONE);
1186 }
1187
1188 /**
1189 * @tc.name: VideoPropertyTest013
1190 * @tc.desc: Create Vdeo, and set its properties.
1191 * @tc.type: FUNC
1192 */
1193 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest013, TestSize.Level1)
1194 {
1195 auto themeManager13 = AceType::MakeRefPtr<MockThemeManager>();
1196 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager13);
1197 EXPECT_CALL(*themeManager13, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1198 /**
1199 * @tc.steps: step1. Create Video
1200 * @tc.expected: step1. Create Video successfully
1201 */
1202 auto frameNode = CreateVideoNode(g_testProperty);
1203 ASSERT_TRUE(frameNode);
1204 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1205 auto pattern13 = frameNode->GetPattern<VideoPattern>();
1206 ASSERT_TRUE(pattern13);
1207
1208 /**
1209 * @tc.steps: step2. Prepare the childNode & videoEvent
1210 */
1211 auto controlBar = frameNode->GetChildAtIndex(2);
1212 ASSERT_TRUE(controlBar);
1213
1214 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1215 ASSERT_TRUE(playBtn);
1216 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1217 ASSERT_TRUE(playBtnGestureEventHub);
1218
1219 // set videoEvent
1220 auto videoEventHub13 = frameNode->GetEventHub<VideoEventHub>();
1221 ASSERT_TRUE(videoEventHub13);
1222 std::string startCheck;
__anon57d7258b3202(const std::string& ) 1223 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1224 std::string pauseCheck;
__anon57d7258b3302(const std::string& ) 1225 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1226 std::string finishCheck;
__anon57d7258b3402(const std::string& ) 1227 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1228 std::string stopCheck;
__anon57d7258b3502(const std::string& ) 1229 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1230 videoEventHub13->SetOnStart(std::move(onStart));
1231 videoEventHub13->SetOnPause(std::move(onPause));
1232 videoEventHub13->SetOnFinish(std::move(onFinish));
1233 videoEventHub13->SetOnStop(std::move(onStop));
1234
1235 /**
1236 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1237 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern13->Pause()
1238 */
1239 pattern13->OnPlayerStatus(PlaybackStatus::STARTED);
1240 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1241 // will call pattern13->Pause()
1242 EXPECT_TRUE(pattern13->isPlaying_);
1243 pattern13->isPlaying_ = false;
1244 auto flag = playBtnGestureEventHub->ActClick();
1245 EXPECT_TRUE(flag);
1246
1247 /**
1248 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1249 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1250 */
1251 // case1: MediaPlayer is invalid
1252 pattern13->OnPlayerStatus(PlaybackStatus::PAUSED);
1253 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1254
1255 /**
1256 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1257 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1258 */
1259 pattern13->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
1260 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1261 auto videoLayoutProperty = pattern13->GetLayoutProperty<VideoLayoutProperty>();
1262 videoLayoutProperty->UpdateControls(false);
1263 }
1264
1265 /**
1266 * @tc.name: VideoPropertyTest014
1267 * @tc.desc: Create Vdeo, and set its properties.
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest014, TestSize.Level1)
1271 {
1272 auto themeManager14 = AceType::MakeRefPtr<MockThemeManager>();
1273 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager14);
1274 EXPECT_CALL(*themeManager14, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1275 /**
1276 * @tc.steps: step1. Create Video
1277 * @tc.expected: step1. Create Video successfully
1278 */
1279 auto frameNode = CreateVideoNode(g_testProperty);
1280 ASSERT_TRUE(frameNode);
1281 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1282 auto pattern14 = frameNode->GetPattern<VideoPattern>();
1283 ASSERT_TRUE(pattern14);
1284
1285 /**
1286 * @tc.steps: step2. Prepare the childNode & videoEvent
1287 */
1288 auto controlBar = frameNode->GetChildAtIndex(2);
1289 ASSERT_TRUE(controlBar);
1290
1291 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1292 ASSERT_TRUE(playBtn);
1293 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1294 ASSERT_TRUE(playBtnGestureEventHub);
1295
1296 // set videoEvent
1297 auto videoEventHub14 = frameNode->GetEventHub<VideoEventHub>();
1298 ASSERT_TRUE(videoEventHub14);
1299 std::string startCheck;
__anon57d7258b3602(const std::string& ) 1300 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1301 std::string pauseCheck;
__anon57d7258b3702(const std::string& ) 1302 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1303 std::string finishCheck;
__anon57d7258b3802(const std::string& ) 1304 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1305 std::string stopCheck;
__anon57d7258b3902(const std::string& ) 1306 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1307 videoEventHub14->SetOnStart(std::move(onStart));
1308 videoEventHub14->SetOnPause(std::move(onPause));
1309 videoEventHub14->SetOnFinish(std::move(onFinish));
1310 videoEventHub14->SetOnStop(std::move(onStop));
1311
1312 /**
1313 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1314 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern14->Pause()
1315 */
1316 pattern14->OnPlayerStatus(PlaybackStatus::STARTED);
1317 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1318 // will call pattern14->Pause()
1319 EXPECT_TRUE(pattern14->isPlaying_);
1320 // case1: MediaPlayer is valid & isPlaying = false
1321 pattern14->isPlaying_ = false;
1322 auto flag = playBtnGestureEventHub->ActClick();
1323 EXPECT_TRUE(flag);
1324
1325 /**
1326 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1327 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1328 */
1329 // case1: MediaPlayer is valid
1330 pauseCheck.clear();
1331 pattern14->OnPlayerStatus(PlaybackStatus::PAUSED);
1332 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1333
1334 /**
1335 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1336 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1337 */
1338 pattern14->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
1339 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1340 auto videoLayoutProperty = pattern14->GetLayoutProperty<VideoLayoutProperty>();
1341 videoLayoutProperty->UpdateControls(false);
1342 }
1343
1344 /**
1345 * @tc.name: VideoPropertyTest015
1346 * @tc.desc: Create Vdeo, and set its properties.
1347 * @tc.type: FUNC
1348 */
1349 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest015, TestSize.Level1)
1350 {
1351 auto themeManager15 = AceType::MakeRefPtr<MockThemeManager>();
1352 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager15);
1353 EXPECT_CALL(*themeManager15, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1354 /**
1355 * @tc.steps: step1. Create Video
1356 * @tc.expected: step1. Create Video successfully
1357 */
1358 auto frameNode = CreateVideoNode(g_testProperty);
1359 ASSERT_TRUE(frameNode);
1360 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1361 auto pattern15 = frameNode->GetPattern<VideoPattern>();
1362 ASSERT_TRUE(pattern15);
1363
1364 /**
1365 * @tc.steps: step2. Prepare the childNode & videoEvent
1366 */
1367 auto controlBar = frameNode->GetChildAtIndex(2);
1368 ASSERT_TRUE(controlBar);
1369
1370 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1371 ASSERT_TRUE(playBtn);
1372 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1373 ASSERT_TRUE(playBtnGestureEventHub);
1374
1375 // set videoEvent
1376 auto videoEventHub15 = frameNode->GetEventHub<VideoEventHub>();
1377 ASSERT_TRUE(videoEventHub15);
1378 std::string startCheck;
__anon57d7258b3a02(const std::string& ) 1379 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1380 std::string pauseCheck;
__anon57d7258b3b02(const std::string& ) 1381 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1382 std::string finishCheck;
__anon57d7258b3c02(const std::string& ) 1383 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1384 std::string stopCheck;
__anon57d7258b3d02(const std::string& ) 1385 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1386 videoEventHub15->SetOnStart(std::move(onStart));
1387 videoEventHub15->SetOnPause(std::move(onPause));
1388 videoEventHub15->SetOnFinish(std::move(onFinish));
1389 videoEventHub15->SetOnStop(std::move(onStop));
1390
1391 /**
1392 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1393 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern15->Pause()
1394 */
1395 pattern15->OnPlayerStatus(PlaybackStatus::STARTED);
1396 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1397 // will call pattern15->Pause()
1398 EXPECT_TRUE(pattern15->isPlaying_);
1399 pattern15->isPlaying_ = false;
1400 auto flag = playBtnGestureEventHub->ActClick();
1401 EXPECT_TRUE(flag);
1402
1403 /**
1404 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1405 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1406 */
1407 // case1: MediaPlayer is invalid
1408 pattern15->OnPlayerStatus(PlaybackStatus::PAUSED);
1409 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1410
1411 /**
1412 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1413 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1414 */
1415 auto videoLayoutProperty = pattern15->GetLayoutProperty<VideoLayoutProperty>();
1416 videoLayoutProperty->UpdateControls(false);
1417 pattern15->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
1418 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1419 pattern15->OnPlayerStatus(PlaybackStatus::ERROR);
1420 pattern15->OnPlayerStatus(PlaybackStatus::IDLE);
1421 pattern15->OnPlayerStatus(PlaybackStatus::PREPARED);
1422 pattern15->OnPlayerStatus(PlaybackStatus::PAUSED);
1423 pattern15->OnPlayerStatus(PlaybackStatus::STOPPED);
1424 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
1425 pattern15->OnPlayerStatus(PlaybackStatus::NONE);
1426 }
1427
1428 /**
1429 * @tc.name: VideoPropertyTest016
1430 * @tc.desc: Create Vdeo, and set its properties.
1431 * @tc.type: FUNC
1432 */
1433 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest016, TestSize.Level1)
1434 {
1435 auto themeManager16 = AceType::MakeRefPtr<MockThemeManager>();
1436 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager16);
1437 EXPECT_CALL(*themeManager16, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1438 /**
1439 * @tc.steps: step1. Create Video
1440 * @tc.expected: step1. Create Video successfully
1441 */
1442 auto frameNode = CreateVideoNode(g_testProperty);
1443 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1444 auto pattern16 = frameNode->GetPattern<VideoPattern>();
1445
1446 /**
1447 * @tc.steps: step2. Prepare the childNode & videoEvent
1448 */
1449 auto controlBar = frameNode->GetChildAtIndex(2);
1450 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1451 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1452
1453 // set videoEvent
1454 auto videoEventHub16 = frameNode->GetEventHub<VideoEventHub>();
1455 ASSERT_TRUE(videoEventHub16);
1456 std::string startCheck;
__anon57d7258b3e02(const std::string& ) 1457 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1458 std::string pauseCheck;
__anon57d7258b3f02(const std::string& ) 1459 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1460 std::string finishCheck;
__anon57d7258b4002(const std::string& ) 1461 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1462 std::string stopCheck;
__anon57d7258b4102(const std::string& ) 1463 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1464 videoEventHub16->SetOnStart(std::move(onStart));
1465 videoEventHub16->SetOnPause(std::move(onPause));
1466 videoEventHub16->SetOnFinish(std::move(onFinish));
1467 videoEventHub16->SetOnStop(std::move(onStop));
1468
1469 /**
1470 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1471 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern16->Pause()
1472 */
1473 pattern16->OnPlayerStatus(PlaybackStatus::STARTED);
1474 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1475 // will call pattern16->Pause()
1476 EXPECT_TRUE(pattern16->isPlaying_);
1477 pattern16->isPlaying_ = false;
1478 auto flag = playBtnGestureEventHub->ActClick();
1479 EXPECT_TRUE(flag);
1480
1481 /**
1482 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1483 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1484 */
1485 // case1: MediaPlayer is invalid
1486 pattern16->OnPlayerStatus(PlaybackStatus::PAUSED);
1487 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1488
1489 // case1: MediaPlayer is valid
1490 pauseCheck.clear();
1491 pattern16->OnPlayerStatus(PlaybackStatus::PAUSED);
1492 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1493
1494 /**
1495 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1496 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1497 */
1498 auto videoLayoutProperty = pattern16->GetLayoutProperty<VideoLayoutProperty>();
1499 videoLayoutProperty->UpdateControls(false);
1500 pattern16->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
1501 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1502 pattern16->OnPlayerStatus(PlaybackStatus::ERROR);
1503 pattern16->OnPlayerStatus(PlaybackStatus::IDLE);
1504 pattern16->OnPlayerStatus(PlaybackStatus::PREPARED);
1505 pattern16->OnPlayerStatus(PlaybackStatus::PAUSED);
1506 pattern16->OnPlayerStatus(PlaybackStatus::STOPPED);
1507 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
1508 pattern16->OnPlayerStatus(PlaybackStatus::NONE);
1509 }
1510
1511 /**
1512 * @tc.name: VideoPropertyTest017
1513 * @tc.desc: Create Vdeo, and set its properties.
1514 * @tc.type: FUNC
1515 */
1516 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest017, TestSize.Level1)
1517 {
1518 auto themeManager17 = AceType::MakeRefPtr<MockThemeManager>();
1519 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager17);
1520 EXPECT_CALL(*themeManager17, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1521 /**
1522 * @tc.steps: step1. Create Video
1523 * @tc.expected: step1. Create Video successfully
1524 */
1525 auto frameNode = CreateVideoNode(g_testProperty);
1526 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1527 auto pattern17 = frameNode->GetPattern<VideoPattern>();
1528
1529 /**
1530 * @tc.steps: step2. Prepare the childNode & videoEvent
1531 */
1532 auto controlBar = frameNode->GetChildAtIndex(2);
1533 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1534 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1535 ASSERT_TRUE(playBtnGestureEventHub);
1536
1537 // set videoEvent
1538 auto videoEventHub17 = frameNode->GetEventHub<VideoEventHub>();
1539 ASSERT_TRUE(videoEventHub17);
1540 std::string startCheck;
__anon57d7258b4202(const std::string& ) 1541 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1542 std::string pauseCheck;
__anon57d7258b4302(const std::string& ) 1543 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1544 std::string finishCheck;
__anon57d7258b4402(const std::string& ) 1545 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1546 std::string stopCheck;
__anon57d7258b4502(const std::string& ) 1547 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1548 videoEventHub17->SetOnStart(std::move(onStart));
1549 videoEventHub17->SetOnPause(std::move(onPause));
1550 videoEventHub17->SetOnFinish(std::move(onFinish));
1551 videoEventHub17->SetOnStop(std::move(onStop));
1552
1553 /**
1554 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1555 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern17->Pause()
1556 */
1557 pattern17->OnPlayerStatus(PlaybackStatus::STARTED);
1558 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1559 // will call pattern17->Pause()
1560 EXPECT_TRUE(pattern17->isPlaying_);
1561 // case1: MediaPlayer is valid & isPlaying = true
1562 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(pattern17->mediaPlayer_)),
1563 Pause()).Times(1).WillOnce(Return(0));
1564 auto flag = playBtnGestureEventHub->ActClick();
1565 EXPECT_TRUE(flag);
1566
1567 /**
1568 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1569 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1570 */
1571 // case1: MediaPlayer is invalid
1572 pattern17->OnPlayerStatus(PlaybackStatus::PAUSED);
1573 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1574
1575 /**
1576 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1577 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1578 */
1579 pattern17->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
1580 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1581 auto videoLayoutProperty = pattern17->GetLayoutProperty<VideoLayoutProperty>();
1582 videoLayoutProperty->UpdateControls(false);
1583 pattern17->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
1584 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1585 pattern17->OnPlayerStatus(PlaybackStatus::ERROR);
1586 pattern17->OnPlayerStatus(PlaybackStatus::IDLE);
1587 pattern17->OnPlayerStatus(PlaybackStatus::PREPARED);
1588 pattern17->OnPlayerStatus(PlaybackStatus::PAUSED);
1589 pattern17->OnPlayerStatus(PlaybackStatus::STOPPED);
1590 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
1591 pattern17->OnPlayerStatus(PlaybackStatus::NONE);
1592 }
1593
1594 /**
1595 * @tc.name: VideoPropertyTest018
1596 * @tc.desc: Create Vdeo, and set its properties.
1597 * @tc.type: FUNC
1598 */
1599 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest018, TestSize.Level1)
1600 {
1601 auto themeManager18 = AceType::MakeRefPtr<MockThemeManager>();
1602 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager18);
1603 EXPECT_CALL(*themeManager18, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1604 /**
1605 * @tc.steps: step1. Create Video
1606 * @tc.expected: step1. Create Video successfully
1607 */
1608 auto frameNode = CreateVideoNode(g_testProperty);
1609 ASSERT_TRUE(frameNode);
1610 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1611 auto pattern18 = frameNode->GetPattern<VideoPattern>();
1612 ASSERT_TRUE(pattern18);
1613
1614 /**
1615 * @tc.steps: step2. Prepare the childNode & videoEvent
1616 */
1617 auto controlBar = frameNode->GetChildAtIndex(2);
1618 ASSERT_TRUE(controlBar);
1619
1620 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1621 ASSERT_TRUE(playBtn);
1622 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1623 ASSERT_TRUE(playBtnGestureEventHub);
1624
1625 // set videoEvent
1626 auto videoEventHub18 = frameNode->GetEventHub<VideoEventHub>();
1627 ASSERT_TRUE(videoEventHub18);
1628 std::string startCheck;
__anon57d7258b4602(const std::string& ) 1629 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1630 std::string pauseCheck;
__anon57d7258b4702(const std::string& ) 1631 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1632 std::string finishCheck;
__anon57d7258b4802(const std::string& ) 1633 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1634 std::string stopCheck;
__anon57d7258b4902(const std::string& ) 1635 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1636 videoEventHub18->SetOnStart(std::move(onStart));
1637 videoEventHub18->SetOnPause(std::move(onPause));
1638 videoEventHub18->SetOnFinish(std::move(onFinish));
1639 videoEventHub18->SetOnStop(std::move(onStop));
1640
1641 /**
1642 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1643 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern18->Pause()
1644 */
1645 pattern18->OnPlayerStatus(PlaybackStatus::STARTED);
1646 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1647 // will call pattern18->Pause()
1648 EXPECT_TRUE(pattern18->isPlaying_);
1649 // case1: MediaPlayer is valid & isPlaying = true
1650 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(pattern18->mediaPlayer_)),
1651 Pause()).Times(1).WillOnce(Return(0));
1652 auto flag = playBtnGestureEventHub->ActClick();
1653 EXPECT_TRUE(flag);
1654
1655 /**
1656 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1657 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1658 */
1659 // case1: MediaPlayer is invalid
1660 pattern18->OnPlayerStatus(PlaybackStatus::PAUSED);
1661 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1662
1663 /**
1664 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1665 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1666 */
1667 auto videoLayoutProperty = pattern18->GetLayoutProperty<VideoLayoutProperty>();
1668 videoLayoutProperty->UpdateControls(false);
1669 pattern18->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
1670 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1671 pattern18->OnPlayerStatus(PlaybackStatus::ERROR);
1672 pattern18->OnPlayerStatus(PlaybackStatus::IDLE);
1673 pattern18->OnPlayerStatus(PlaybackStatus::PREPARED);
1674 pattern18->OnPlayerStatus(PlaybackStatus::PAUSED);
1675 pattern18->OnPlayerStatus(PlaybackStatus::STOPPED);
1676 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
1677 pattern18->OnPlayerStatus(PlaybackStatus::NONE);
1678 }
1679
1680 /**
1681 * @tc.name: VideoPropertyTest019
1682 * @tc.desc: Create Vdeo, and set its properties.
1683 * @tc.type: FUNC
1684 */
1685 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest019, TestSize.Level1)
1686 {
1687 auto themeManager19 = AceType::MakeRefPtr<MockThemeManager>();
1688 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager19);
1689 EXPECT_CALL(*themeManager19, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1690 /**
1691 * @tc.steps: step1. Create Video
1692 * @tc.expected: step1. Create Video successfully
1693 */
1694 auto frameNode = CreateVideoNode(g_testProperty);
1695 ASSERT_TRUE(frameNode);
1696 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1697 auto pattern19 = frameNode->GetPattern<VideoPattern>();
1698 ASSERT_TRUE(pattern19);
1699
1700 /**
1701 * @tc.steps: step2. Prepare the childNode & videoEvent
1702 */
1703 auto controlBar = frameNode->GetChildAtIndex(2);
1704 ASSERT_TRUE(controlBar);
1705
1706 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1707 ASSERT_TRUE(playBtn);
1708 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1709 ASSERT_TRUE(playBtnGestureEventHub);
1710
1711 // set videoEvent
1712 auto videoEventHub19 = frameNode->GetEventHub<VideoEventHub>();
1713 ASSERT_TRUE(videoEventHub19);
1714 std::string startCheck;
__anon57d7258b4a02(const std::string& ) 1715 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1716 std::string pauseCheck;
__anon57d7258b4b02(const std::string& ) 1717 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1718 std::string finishCheck;
__anon57d7258b4c02(const std::string& ) 1719 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1720 std::string stopCheck;
__anon57d7258b4d02(const std::string& ) 1721 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1722 videoEventHub19->SetOnStart(std::move(onStart));
1723 videoEventHub19->SetOnPause(std::move(onPause));
1724 videoEventHub19->SetOnFinish(std::move(onFinish));
1725 videoEventHub19->SetOnStop(std::move(onStop));
1726
1727 /**
1728 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1729 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern19->Pause()
1730 */
1731 pattern19->OnPlayerStatus(PlaybackStatus::STARTED);
1732 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1733 // will call pattern19->Pause()
1734 EXPECT_TRUE(pattern19->isPlaying_);
1735 // case1: MediaPlayer is valid & isPlaying = true
1736 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(pattern19->mediaPlayer_)),
1737 Pause()).Times(1).WillOnce(Return(0));
1738 auto flag = playBtnGestureEventHub->ActClick();
1739 EXPECT_TRUE(flag);
1740
1741 /**
1742 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1743 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1744 */
1745 // case1: MediaPlayer is valid
1746 pauseCheck.clear();
1747 pattern19->OnPlayerStatus(PlaybackStatus::PAUSED);
1748 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1749
1750 /**
1751 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1752 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1753 */
1754 pattern19->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
1755 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1756 auto videoLayoutProperty = pattern19->GetLayoutProperty<VideoLayoutProperty>();
1757 videoLayoutProperty->UpdateControls(false);
1758 }
1759
1760 /**
1761 * @tc.name: VideoPropertyTest020
1762 * @tc.desc: Create Vdeo, and set its properties.
1763 * @tc.type: FUNC
1764 */
1765 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest020, TestSize.Level1)
1766 {
1767 auto themeManager20 = AceType::MakeRefPtr<MockThemeManager>();
1768 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager20);
1769 EXPECT_CALL(*themeManager20, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1770 /**
1771 * @tc.steps: step1. Create Video
1772 * @tc.expected: step1. Create Video successfully
1773 */
1774 auto frameNode = CreateVideoNode(g_testProperty);
1775 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1776 auto pattern20 = frameNode->GetPattern<VideoPattern>();
1777
1778 /**
1779 * @tc.steps: step2. Prepare the childNode & videoEvent
1780 */
1781 auto controlBar = frameNode->GetChildAtIndex(2);
1782 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1783 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1784
1785 // set videoEvent
1786 auto videoEventHub20 = frameNode->GetEventHub<VideoEventHub>();
1787 ASSERT_TRUE(videoEventHub20);
1788 std::string startCheck;
__anon57d7258b4e02(const std::string& ) 1789 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1790 std::string pauseCheck;
__anon57d7258b4f02(const std::string& ) 1791 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1792 std::string finishCheck;
__anon57d7258b5002(const std::string& ) 1793 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1794 std::string stopCheck;
__anon57d7258b5102(const std::string& ) 1795 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1796 videoEventHub20->SetOnStart(std::move(onStart));
1797 videoEventHub20->SetOnPause(std::move(onPause));
1798 videoEventHub20->SetOnFinish(std::move(onFinish));
1799 videoEventHub20->SetOnStop(std::move(onStop));
1800
1801 /**
1802 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1803 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern20->Pause()
1804 */
1805 pattern20->OnPlayerStatus(PlaybackStatus::STARTED);
1806 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1807 // will call pattern20->Pause()
1808 EXPECT_TRUE(pattern20->isPlaying_);
1809 // case1: MediaPlayer is valid & isPlaying = true
1810 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(pattern20->mediaPlayer_)),
1811 Pause()).Times(1).WillOnce(Return(0));
1812 auto flag = playBtnGestureEventHub->ActClick();
1813 EXPECT_TRUE(flag);
1814
1815 /**
1816 * @tc.steps: step4. Call OnPlayerStatus status == PREPARED
1817 * @tc.expected: step4. FirePauseEvent & mediaPlayer->GetDuration() has called
1818 */
1819 // case1: MediaPlayer is valid
1820 pauseCheck.clear();
1821 pattern20->OnPlayerStatus(PlaybackStatus::PAUSED);
1822 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1823
1824 /**
1825 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1826 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1827 */
1828 auto videoLayoutProperty = pattern20->GetLayoutProperty<VideoLayoutProperty>();
1829 videoLayoutProperty->UpdateControls(false);
1830 pattern20->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
1831 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1832 pattern20->OnPlayerStatus(PlaybackStatus::ERROR);
1833 pattern20->OnPlayerStatus(PlaybackStatus::IDLE);
1834 pattern20->OnPlayerStatus(PlaybackStatus::PREPARED);
1835 pattern20->OnPlayerStatus(PlaybackStatus::PAUSED);
1836 pattern20->OnPlayerStatus(PlaybackStatus::STOPPED);
1837 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
1838 pattern20->OnPlayerStatus(PlaybackStatus::NONE);
1839 }
1840
1841 /**
1842 * @tc.name: VideoPropertyTest021
1843 * @tc.desc: Create Vdeo, and set its properties.
1844 * @tc.type: FUNC
1845 */
1846 HWTEST_F(VideoTestAddNg, OnPlayerStatusTest021, TestSize.Level1)
1847 {
1848 auto themeManager21 = AceType::MakeRefPtr<MockThemeManager>();
1849 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager21);
1850 EXPECT_CALL(*themeManager21, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<VideoTheme>()));
1851 /**
1852 * @tc.steps: step1. Create Video
1853 * @tc.expected: step1. Create Video successfully
1854 */
1855 auto frameNode = CreateVideoNode(g_testProperty);
1856 EXPECT_EQ(frameNode->GetTag(), V2::VIDEO_ETS_TAG);
1857 auto pattern21 = frameNode->GetPattern<VideoPattern>();
1858
1859 /**
1860 * @tc.steps: step2. Prepare the childNode & videoEvent
1861 */
1862 auto controlBar = frameNode->GetChildAtIndex(2);
1863 auto playBtn = AceType::DynamicCast<FrameNode>(controlBar->GetChildAtIndex(0));
1864 auto playBtnGestureEventHub = playBtn->GetOrCreateGestureEventHub();
1865
1866 // set videoEvent
1867 auto videoEventHub21 = frameNode->GetEventHub<VideoEventHub>();
1868 std::string startCheck;
__anon57d7258b5202(const std::string& ) 1869 VideoEventCallback onStart = [&startCheck](const std::string& /* param */) { startCheck = VIDEO_START_EVENT; };
1870 std::string pauseCheck;
__anon57d7258b5302(const std::string& ) 1871 VideoEventCallback onPause = [&pauseCheck](const std::string& /* param */) { pauseCheck = VIDEO_PAUSE_EVENT; };
1872 std::string finishCheck;
__anon57d7258b5402(const std::string& ) 1873 VideoEventCallback onFinish = [&finishCheck](const std::string& /* param */) { finishCheck = VIDEO_FINISH_EVENT; };
1874 std::string stopCheck;
__anon57d7258b5502(const std::string& ) 1875 VideoEventCallback onStop = [&stopCheck](const std::string& /* param */) { stopCheck = VIDEO_STOP_EVENT; };
1876 videoEventHub21->SetOnStart(std::move(onStart));
1877 videoEventHub21->SetOnPause(std::move(onPause));
1878 videoEventHub21->SetOnFinish(std::move(onFinish));
1879 videoEventHub21->SetOnStop(std::move(onStop));
1880
1881 /**
1882 * @tc.steps: step3. Call OnPlayerStatus status == STARTED
1883 * @tc.expected: step3. FireStartEvent has called and playBtn event will call pattern21->Pause()
1884 */
1885 pattern21->OnPlayerStatus(PlaybackStatus::STARTED);
1886 EXPECT_EQ(startCheck, VIDEO_START_EVENT);
1887 // will call pattern21->Pause()
1888 EXPECT_TRUE(pattern21->isPlaying_);
1889 // case1: MediaPlayer is invalid
1890 auto flag = playBtnGestureEventHub->ActClick();
1891 EXPECT_TRUE(flag);
1892 // case2: MediaPlayer is valid & isPlaying = true
1893 EXPECT_CALL(*(AceType::DynamicCast<MockMediaPlayer>(pattern21->mediaPlayer_)),
1894 Pause()).Times(2).WillOnce(Return(0));
1895 flag = playBtnGestureEventHub->ActClick();
1896 EXPECT_TRUE(flag);
1897 // case3: MediaPlayer is valid & isPlaying = false
1898 pattern21->isPlaying_ = false;
1899 flag = playBtnGestureEventHub->ActClick();
1900 EXPECT_TRUE(flag);
1901 pattern21->OnPlayerStatus(PlaybackStatus::PAUSED);
1902 EXPECT_EQ(pauseCheck, VIDEO_PAUSE_EVENT);
1903
1904 /**
1905 * @tc.steps: step5. Call OnPlayerStatus status == PLAYBACK_COMPLETE
1906 * @tc.expected: step5. FireFinishEvent & OnUpdateTime(pos = CURRENT_POS) will be called
1907 */
1908 pattern21->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case1: controls = true
1909 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1910 auto videoLayoutProperty = pattern21->GetLayoutProperty<VideoLayoutProperty>();
1911 videoLayoutProperty->UpdateControls(false);
1912 pattern21->OnPlayerStatus(PlaybackStatus::PLAYBACK_COMPLETE); // case2: controls = false
1913 EXPECT_EQ(finishCheck, VIDEO_FINISH_EVENT);
1914 pattern21->OnPlayerStatus(PlaybackStatus::ERROR);
1915 pattern21->OnPlayerStatus(PlaybackStatus::IDLE);
1916 pattern21->OnPlayerStatus(PlaybackStatus::PREPARED);
1917 pattern21->OnPlayerStatus(PlaybackStatus::PAUSED);
1918 pattern21->OnPlayerStatus(PlaybackStatus::STOPPED);
1919 EXPECT_EQ(stopCheck, VIDEO_STOP_EVENT);
1920 }
1921 } // namespace OHOS::Ace::NG
