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