| # Copyright 2021 The Cobalt Authors. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| """ Endurance test of playbacks.""" |
| |
| import argparse |
| import logging |
| import random |
| import time |
| |
| import _env # pylint: disable=unused-import |
| from cobalt.media_integration_tests.test_app import Features, MediaSessionPlaybackState |
| from cobalt.media_integration_tests.test_case import TestCase |
| from cobalt.media_integration_tests.test_util import PlaybackUrls |
| |
| # The variables below are all in seconds. |
| STATUS_CHECK_INTERVAL = 0.5 |
| SINGLE_PLAYBACK_WATCH_TIME_MAXIMUM = 2.0 * 60 * 60 |
| PLAYER_INITIALIZATION_WAITING_TIMEOUT = 5.0 * 60 |
| MEDIA_TIME_UPDATE_WAITING_TIMEOUT = 10.0 |
| WRITTEN_INPUT_WAITING_TIMEOUT = 30.0 |
| PLAYBACK_END_WAITING_TIMEOUT = 30.0 |
| # Needs to interact with the app regularly to keep it active. Otherwise, the |
| # playback may be paused. |
| IDLE_TIME_MAXIMUM = 60 * 60 |
| |
| |
| class EnduranceTest(TestCase): |
| """ |
| Test case for playback endurance test. |
| """ |
| |
| def __init__(self, *args, **kwargs): |
| super(EnduranceTest, self).__init__(*args, **kwargs) |
| |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| '--startup_url', default=PlaybackUrls.PLAYLIST, type=str) |
| # Stop the test after |max_running_time| (in hours). If |max_running_time| |
| # is 0 or negative, the test will not stop until it gets an error. |
| parser.add_argument('--max_running_time', default=20, type=float) |
| # Insert random actions if |random_action_interval| is greater than 0. |
| parser.add_argument('--random_action_interval', default=0.0, type=float) |
| args, _ = parser.parse_known_args() |
| |
| self.startup_url = args.startup_url |
| # Convert |max_running_time| to seconds. |
| self.max_running_time = args.max_running_time * 60 * 60 |
| self.needs_random_action = args.random_action_interval > 0 |
| self.random_action_interval = args.random_action_interval |
| |
| def ResetTimestamps(self): |
| self.last_media_time = -1 |
| self.last_media_time_update_time = -1 |
| self.last_written_audio_timestamp = -1 |
| self.last_written_audio_update_time = -1 |
| self.last_written_video_timestamp = -1 |
| self.last_written_video_update_time = -1 |
| self.audio_eos_written_time = -1 |
| self.video_eos_written_time = -1 |
| self.playback_end_time = -1 |
| |
| def OnPlayerStateChanged(self, player_state_handler, player_state): |
| current_running_time = time.time() - self.start_time |
| element_state = player_state.video_element_state |
| pipeline_state = player_state.pipeline_state |
| media_session_state = player_state.media_session_state |
| |
| if not player_state_handler.IsPlayerPlaying(): |
| return |
| |
| # Reset timestamps after player identifier is changed. |
| if self.player_identifier != pipeline_state.identifier: |
| self.player_identifier = pipeline_state.identifier |
| self.playback_start_time = current_running_time |
| self.ResetTimestamps() |
| |
| # Reset timestamps after resume. It could happen after pause, fastforward, |
| # rewind and playback switch. |
| if media_session_state.playback_state != MediaSessionPlaybackState.PLAYING: |
| self.playback_is_playing = False |
| elif not self.playback_is_playing: |
| self.playback_is_playing = True |
| self.ResetTimestamps() |
| |
| # Update media time. |
| if self.last_media_time != element_state.current_time: |
| self.last_media_time = element_state.current_time |
| self.last_media_time_update_time = current_running_time |
| |
| # Update written audio timestamp. |
| if (self.last_written_audio_timestamp != |
| pipeline_state.last_written_audio_timestamp): |
| self.last_written_audio_timestamp = ( |
| pipeline_state.last_written_audio_timestamp) |
| self.last_written_audio_update_time = current_running_time |
| |
| # Update written video timestamp. |
| if (self.last_written_video_timestamp != |
| pipeline_state.last_written_video_timestamp): |
| self.last_written_video_timestamp = ( |
| pipeline_state.last_written_video_timestamp) |
| self.last_written_video_update_time = current_running_time |
| |
| # Update audio eos timestamp. |
| if (self.audio_eos_written_time == -1 and |
| pipeline_state.is_audio_eos_written): |
| self.audio_eos_written_time = current_running_time |
| |
| # Update video eos timestamp. |
| if (self.video_eos_written_time == -1 and |
| pipeline_state.is_video_eos_written): |
| self.video_eos_written_time = current_running_time |
| |
| # Update playback end time. |
| if (self.audio_eos_written_time != -1 and |
| self.video_eos_written_time != -1 and self.playback_end_time == -1 and |
| element_state.current_time >= element_state.duration): |
| self.playback_end_time = current_running_time |
| |
| def GenerateErrorString(self, err_msg): |
| return ( |
| '%s (running time: %f, player identifier: "%s", is playing: %r, ' |
| 'playback start time: %f, last media time: %f (updated at %f), ' |
| 'last written audio timestamp: %d (updated at %f), ' |
| 'last written video timestamp: %d (updated at %f), ' |
| 'audio eos written at %f, video eos written at %f, ' |
| 'playback ended at %f).' % |
| (err_msg, time.time() - self.start_time, self.player_identifier, |
| self.playback_is_playing, self.playback_start_time, |
| self.last_media_time, self.last_media_time_update_time, |
| self.last_written_audio_timestamp, self.last_written_audio_update_time, |
| self.last_written_video_timestamp, self.last_written_video_update_time, |
| self.audio_eos_written_time, self.video_eos_written_time, |
| self.playback_end_time)) |
| |
| def SendRandomAction(self, app): |
| |
| def SuspendAndResume(app): |
| app.Suspend() |
| app.WaitUntilReachState( |
| lambda _app: not _app.ApplicationState().is_visible) |
| # Wait for 1 second before resume. |
| time.sleep(1) |
| app.Resume() |
| |
| actions = { |
| 'PlayPause': lambda _app: _app.PlayOrPause(), |
| 'Fastforward': lambda _app: _app.Fastforward(), |
| 'Rewind': lambda _app: _app.Rewind(), |
| 'PlayPrevious': lambda _app: _app.PlayPrevious(), |
| 'PlayNext': lambda _app: _app.PlayNext(), |
| } |
| if TestCase.IsFeatureSupported(Features.SUSPEND_AND_RESUME): |
| actions['SuspendAndResume'] = SuspendAndResume |
| |
| action_name = random.choice(list(actions.keys())) |
| logging.info('Send random action (%s).', action_name) |
| actions[action_name](app) |
| |
| def test_playback_endurance(self): |
| self.start_time = time.time() |
| self.player_identifier = '' |
| self.playback_is_playing = False |
| self.playback_start_time = -1 |
| self.last_state_check_time = 0 |
| self.last_action_time = 0 |
| self.ResetTimestamps() |
| |
| app = self.CreateCobaltApp(self.startup_url) |
| app.AddPlayerStateChangeHandler(self.OnPlayerStateChanged) |
| with app: |
| while True: |
| # Put the sleep at the top of the loop. |
| time.sleep(STATUS_CHECK_INTERVAL) |
| |
| current_running_time = time.time() - self.start_time |
| # Stop the test after reaching max running time. |
| if (self.max_running_time > 0 and |
| current_running_time > self.max_running_time): |
| break |
| # Skip if there's no running player. |
| if not app.player_state_handler.IsPlayerPlaying(): |
| # TODO: identify network problem |
| self.assertTrue( |
| current_running_time - self.last_state_check_time < |
| PLAYER_INITIALIZATION_WAITING_TIMEOUT, |
| self.GenerateErrorString( |
| 'Timed out waiting for player initialization (waited: %f).' % |
| (current_running_time - self.last_state_check_time))) |
| continue |
| self.last_state_check_time = current_running_time |
| # Skip to next playback if it has been played for long time. |
| if (self.playback_start_time != -1 and |
| current_running_time - self.playback_start_time > |
| SINGLE_PLAYBACK_WATCH_TIME_MAXIMUM): |
| app.PlayNext() |
| # Set start time to -1 here to avoid send same command in next loop. |
| self.playback_start_time = -1 |
| continue |
| if self.playback_is_playing: |
| # Check media time. |
| if self.last_media_time_update_time > 0: |
| # TODO: identify network problem |
| self.assertTrue( |
| current_running_time - self.last_media_time_update_time < |
| MEDIA_TIME_UPDATE_WAITING_TIMEOUT, |
| self.GenerateErrorString( |
| 'Timed out waiting for media time update (waited: %f).' % |
| (current_running_time - self.last_media_time_update_time))) |
| # Check written audio timestamp. |
| if (self.last_written_audio_update_time > 0 and |
| self.audio_eos_written_time == -1): |
| self.assertTrue( |
| current_running_time - self.last_written_audio_update_time < |
| WRITTEN_INPUT_WAITING_TIMEOUT, |
| self.GenerateErrorString( |
| 'Timed out waiting for new audio input (waited: %f).' % |
| (current_running_time - |
| self.last_written_audio_update_time))) |
| # Check written video timestamp. |
| if (self.last_written_video_update_time > 0 and |
| self.video_eos_written_time == -1): |
| self.assertTrue( |
| current_running_time - self.last_written_video_update_time < |
| WRITTEN_INPUT_WAITING_TIMEOUT, |
| self.GenerateErrorString( |
| 'Timed out waiting for new video input (waited: %f).' % |
| (current_running_time - |
| self.last_written_video_update_time))) |
| # Check if the playback ends properly. |
| if (self.audio_eos_written_time > 0 and |
| self.video_eos_written_time > 0 and self.playback_end_time > 0): |
| self.assertTrue( |
| current_running_time - self.playback_end_time < |
| PLAYBACK_END_WAITING_TIMEOUT, |
| self.GenerateErrorString( |
| 'Timed out waiting for playback to end (waited: %f).' % |
| (current_running_time - self.playback_end_time,))) |
| |
| # Send random actions. |
| if (self.needs_random_action and |
| current_running_time - self.last_action_time > |
| self.random_action_interval): |
| self.SendRandomAction(app) |
| self.last_action_time = current_running_time |
| |
| # Interact with the app to keep it active. |
| if current_running_time - self.last_action_time > IDLE_TIME_MAXIMUM: |
| # Play the previous playback again. |
| app.PlayPrevious() |
| self.last_action_time = current_running_time |
| |
| app.RemovePlayerStateChangeHandler(self.OnPlayerStateChanged) |
