| # Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import logging |
| import operator |
| import os |
| import time |
| |
| from autotest_lib.client.bin import test |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib.cros import chrome |
| from autotest_lib.client.cros.video import helper_logger |
| |
| |
| class video_YouTubePage(test.test): |
| """The main test class of this test. |
| |
| """ |
| |
| |
| version = 1 |
| |
| PSEUDO_RANDOM_TIME_1 = 20.25 |
| PSEUDO_RANDOM_TIME_2 = 5.47 |
| |
| # Minimum number of timeupdates required to fire in the last second. |
| MIN_LAST_SECOND_UPDATES = 3 |
| |
| NO_DELAY = 0 |
| MINIMAL_DELAY = 1 |
| MAX_REBUFFER_DELAY = 10 |
| |
| PLAYING_STATE = 'playing' |
| PAUSED_STATE = 'paused' |
| ENDED_STATE = 'ended' |
| TEST_PAGE = 'http://web-release-qa.youtube.com/watch?v=zuzaxlddWbk&html5=1' |
| |
| DISABLE_COOKIES = False |
| |
| tab = None |
| |
| |
| def initialize_test(self, chrome, player_page): |
| """Initializes the test. |
| |
| @param chrome: An Autotest Chrome instance. |
| @param player_page: The URL (string) of the YouTube player page to test. |
| |
| """ |
| self.tab = chrome.browser.tabs[0] |
| |
| self.tab.Navigate(player_page) |
| self.tab.WaitForDocumentReadyStateToBeComplete() |
| time.sleep(2) |
| |
| with open( |
| os.path.join(os.path.dirname(__file__), |
| 'files/video_YouTubePageCommon.js')) as f: |
| js = f.read() |
| if not self.tab.EvaluateJavaScript(js): |
| raise error.TestFail('YouTube page failed to load.') |
| logging.info('Loaded accompanying .js script.') |
| |
| |
| def get_player_state(self): |
| """Simple wrapper to get the JS player state. |
| |
| @returns: The state of the player (string). |
| |
| """ |
| return self.tab.EvaluateJavaScript('window.__getVideoState();') |
| |
| |
| def play_video(self): |
| """Simple wrapper to play the video. |
| |
| """ |
| self.tab.ExecuteJavaScript('window.__playVideo();') |
| |
| |
| def pause_video(self): |
| """Simple wrapper to pause the video. |
| |
| """ |
| self.tab.ExecuteJavaScript('window.__pauseVideo();') |
| |
| |
| def seek_video(self, new_time): |
| """Simple wrapper to seek the video to a new time. |
| |
| @param new_time: Time to seek to. |
| |
| """ |
| self.tab.ExecuteJavaScript('window.__seek(%f);' % new_time) |
| |
| |
| def seek_to_almost_end(self, seconds_before_end): |
| """Simple wrapper to seek to almost the end of the video. |
| |
| @param seconds_before_end: How many seconds (a float, not integer) |
| before end of video. |
| |
| """ |
| self.tab.ExecuteJavaScript( |
| 'window.__seekToAlmostEnd(%f);' % seconds_before_end) |
| |
| |
| def get_current_time(self): |
| """Simple wrapper to get the current time in the video. |
| |
| @returns: The current time (float). |
| |
| """ |
| return self.tab.EvaluateJavaScript('window.__getCurrentTime();') |
| |
| |
| def assert_event_state(self, event, op, error_str): |
| """Simple wrapper to get the status of a state in the video. |
| |
| @param event: A string denoting the event. Check the accompanying JS |
| file for the possible values. |
| @param op: truth or not_ operator from the standard Python operator |
| module. |
| @param error_str: A string for the error output. |
| |
| @returns: Whether or not the input event has fired. |
| |
| """ |
| result = self.tab.EvaluateJavaScript( |
| 'window.__getEventHappened("%s");' % event) |
| if not op(result): |
| raise error.TestError(error) |
| |
| |
| def clear_event_state(self, event): |
| """Simple wrapper to clear the status of a state in the video. |
| |
| @param event: A string denoting the event. Check the accompanying JS |
| file for the possible vlaues. |
| |
| """ |
| self.tab.ExecuteJavaScript('window.__clearEventHappened("%s");' % event) |
| |
| |
| def verify_last_second_playback(self): |
| """Simple wrapper to check the playback of the last second. |
| |
| """ |
| result = self.tab.EvaluateJavaScript( |
| 'window.__getLastSecondTimeupdates()') |
| if result < self.MIN_LAST_SECOND_UPDATES: |
| raise error.TestError( |
| 'Last second did not play back correctly (%d events).' % |
| result) |
| |
| |
| def assert_player_state(self, state, max_wait_secs): |
| """Simple wrapper to busy wait and test the current state of the player. |
| |
| @param state: A string denoting the expected state of the player. |
| @param max_wait_secs: Maximum amount of time to wait before failing. |
| |
| @raises: A error.TestError if the state is not as expected. |
| |
| """ |
| start_time = time.time() |
| while True: |
| current_state = self.get_player_state() |
| if current_state == state: |
| return |
| elif time.time() < start_time + max_wait_secs: |
| time.sleep(0.5) |
| else: |
| raise error.TestError( |
| 'Current player state "%s" is not the expected state ' |
| '"%s".' % (current_state, state)) |
| |
| |
| def perform_test(self): |
| """Base method for derived classes to run their test. |
| |
| """ |
| raise error.TestFail('Derived class did not specify a perform_test.') |
| |
| |
| def perform_playing_test(self): |
| """Test to check if the YT page starts off playing. |
| |
| """ |
| self.assert_player_state(self.PLAYING_STATE, self.NO_DELAY) |
| if self.get_current_time() <= 0.0: |
| raise error.TestError('perform_playing_test failed.') |
| |
| |
| def perform_pausing_test(self): |
| """Test to check if the video is in the 'paused' state. |
| |
| """ |
| self.assert_player_state(self.PLAYING_STATE, self.NO_DELAY) |
| self.pause_video() |
| self.assert_player_state(self.PAUSED_STATE, self.MINIMAL_DELAY) |
| |
| |
| def perform_resuming_test(self): |
| """Test to check if the video responds to resumption. |
| |
| """ |
| self.assert_player_state(self.PLAYING_STATE, self.NO_DELAY) |
| self.pause_video() |
| self.assert_player_state(self.PAUSED_STATE, self.MINIMAL_DELAY) |
| self.play_video() |
| self.assert_player_state(self.PLAYING_STATE, self.MINIMAL_DELAY) |
| |
| |
| def perform_seeking_test(self): |
| """Test to check if seeking works. |
| |
| """ |
| # Test seeking while playing. |
| self.assert_player_state(self.PLAYING_STATE, self.NO_DELAY) |
| self.seek_video(self.PSEUDO_RANDOM_TIME_1) |
| time.sleep(self.MINIMAL_DELAY) |
| if not self.tab.EvaluateJavaScript( |
| 'window.__getCurrentTime() >= %f;' % self.PSEUDO_RANDOM_TIME_1): |
| raise error.TestError( |
| 'perform_seeking_test failed because player time is not ' |
| 'the expected time during playing seeking.') |
| self.assert_event_state( |
| 'seeking', operator.truth, |
| 'perform_seeking_test failed: "seeking" state did not fire.') |
| self.assert_event_state( |
| 'seeked', operator.truth, |
| 'perform_seeking_test failed: "seeked" state did not fire.') |
| |
| # Now make sure the video is still playing. |
| |
| # Let it buffer/play for at most 10 seconds before continuing. |
| self.assert_player_state(self.PLAYING_STATE, self.MAX_REBUFFER_DELAY) |
| |
| self.clear_event_state('seeking'); |
| self.clear_event_state('seeked'); |
| self.assert_event_state( |
| 'seeking', operator.not_, |
| 'perform_seeking_test failed: ' |
| '"seeking" state did not get cleared.') |
| self.assert_event_state( |
| 'seeked', operator.not_, |
| 'perform_seeking_test failed: ' |
| '"seeked" state did not get cleared.') |
| |
| # Test seeking while paused. |
| self.pause_video() |
| self.assert_player_state(self.PAUSED_STATE, self.MINIMAL_DELAY) |
| |
| self.seek_video(self.PSEUDO_RANDOM_TIME_2) |
| time.sleep(self.MINIMAL_DELAY) |
| if not self.tab.EvaluateJavaScript( |
| 'window.__getCurrentTime() === %f;' % |
| self.PSEUDO_RANDOM_TIME_2): |
| raise error.TestError( |
| 'perform_seeking_test failed because player time is not ' |
| 'the expected time.') |
| self.assert_event_state( |
| 'seeking', operator.truth, |
| 'perform_seeking_test failed: "seeking" state did not fire ' |
| 'again.') |
| self.assert_event_state( |
| 'seeked', operator.truth, |
| 'perform_seeking_test failed: "seeked" state did not fire ' |
| 'again.') |
| |
| # Make sure the video is paused. |
| self.assert_player_state(self.PAUSED_STATE, self.NO_DELAY) |
| |
| |
| def perform_frame_drop_test(self): |
| """Test to check if there are too many dropped frames. |
| |
| """ |
| self.assert_player_state(self.PLAYING_STATE, self.NO_DELAY) |
| time.sleep(15) |
| dropped_frames_percentage = self.tab.EvaluateJavaScript( |
| 'window.__videoElement.webkitDroppedFrameCount /' |
| 'window.__videoElement.webkitDecodedFrameCount') |
| if dropped_frames_percentage > 0.01: |
| raise error.TestError(( |
| 'perform_frame_drop_test failed due to too many dropped ' |
| 'frames (%f%%)') % (dropped_frames_percentage * 100)) |
| |
| |
| def perform_ending_test(self): |
| """Test to check if the state is 'ended' at the end of a video. |
| |
| """ |
| ALMOST_END = 0.1 |
| self.assert_player_state(self.PLAYING_STATE, self.NO_DELAY) |
| self.seek_to_almost_end(ALMOST_END) |
| self.assert_player_state(self.ENDED_STATE, self.MAX_REBUFFER_DELAY) |
| |
| |
| def perform_last_second_test(self): |
| """Test to check if the last second is played. |
| |
| """ |
| NEAR_END = 2.0 |
| self.assert_player_state(self.PLAYING_STATE, self.NO_DELAY) |
| self.seek_to_almost_end(NEAR_END) |
| self.assert_player_state( |
| self.ENDED_STATE, self.MAX_REBUFFER_DELAY + NEAR_END) |
| self.verify_last_second_playback() |
| |
| |
| @helper_logger.video_log_wrapper |
| def run_once(self, subtest_name): |
| """Main runner for the test. |
| |
| @param subtest_name: The name of the test to run, given below. |
| |
| """ |
| extension_paths = [] |
| if self.DISABLE_COOKIES: |
| # To stop the system from erasing the previous profile, enable: |
| # options.dont_override_profile = True |
| extension_path = os.path.join( |
| os.path.dirname(__file__), |
| 'files/cookie-disabler') |
| extension_paths.append(extension_path) |
| |
| |
| with chrome.Chrome( |
| extra_browser_args=helper_logger.chrome_vmodule_flag(), |
| extension_paths=extension_paths) as cr: |
| self.initialize_test(cr, self.TEST_PAGE) |
| |
| if subtest_name is 'playing': |
| self.perform_playing_test() |
| elif subtest_name is 'pausing': |
| self.perform_pausing_test() |
| elif subtest_name is 'resuming': |
| self.perform_resuming_test() |
| elif subtest_name is 'seeking': |
| self.perform_seeking_test() |
| elif subtest_name is 'frame_drop': |
| self.perform_frame_drop_test() |
| elif subtest_name is 'ending': |
| self.perform_ending_test() |
| elif subtest_name is 'last_second': |
| self.perform_last_second_test() |
