| # Copyright 2014 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """This is a display end-to-end test using the Chameleon board.""" |
| |
| import logging, os, shutil, time |
| |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.cros.chameleon import chameleon_port_finder |
| from autotest_lib.client.cros.chameleon import chameleon_screen_test |
| from autotest_lib.client.cros.chameleon import edid |
| from autotest_lib.server import test |
| from autotest_lib.server.cros.multimedia import remote_facade_factory |
| |
| |
| class display_EndToEnd(test.test): |
| """External Display end-toend test. |
| |
| This test talks to a Chameleon board and a DUT to set up, run, and verify |
| DUT behavior response to reboot, login, docked mode, suspend and resume, |
| switching mode, etc. |
| """ |
| version = 1 |
| |
| # Duration of suspend, in second. |
| SUSPEND_DURATION = 30 |
| # Allowed timeout for the transition of suspend. |
| SUSPEND_TIMEOUT = 30 |
| # Allowed timeout for the transition of resume. |
| RESUME_TIMEOUT = 30 |
| # Allowed timeout for reboot. |
| REBOOT_TIMEOUT = 60 |
| # Default waiting time in sec |
| WAIT_TIME = 5 |
| # Crash paths to check for crash meta data |
| CRASH_PATHS = ['/var/spool/crash', |
| '/chronos/home/crash' |
| '/home/chronos/user/crash' |
| ] |
| # EDID data files names for different ports |
| EDID_FILE_NAMES = [('DELL_U3011T_HDMI.txt', 'ASUS_VE258_HDMI.txt'), |
| ('MEL_18546_MDT551S_DP.txt', 'ASUS_VE258_DP.txt')] |
| NO_LID_BOARDS = ['stumpy', 'panther', 'zako', 'tricky', 'mccloud'] |
| |
| def remove_crash_data(self): |
| """delete crash meta files""" |
| for crash_path in self.CRASH_PATHS: |
| if os.path.isdir(crash_path): |
| shutil.rmtree(crash_path) |
| |
| |
| def is_crash_data_present(self): |
| """Check for crash meta files""" |
| for crash_path in self.CRASH_PATHS: |
| if os.path.isdir(crash_path): |
| logging.debug('CRASH detected!') |
| return True |
| return False |
| |
| |
| def switch_display_mode(self): |
| """Switch from extended to mirror and the opposite""" |
| from_mode = 'MIRRORED' if self.test_mirrored else 'EXTENDED' |
| self.test_mirrored = not self.test_mirrored |
| to_mode = 'MIRRORED' if self.test_mirrored else 'EXTENDED' |
| logging.debug('Set mirrored: %s', self.test_mirrored) |
| self.display_facade.set_mirrored(self.test_mirrored) |
| logging.debug('Switched from %s to %s mode', from_mode, to_mode) |
| time.sleep(self.WAIT_TIME) |
| self.check_external_resolution() |
| |
| |
| def reboot_device(self, plugged_before, plugged_after): |
| """Reboot DUT |
| |
| @param plugged_before: a boolean, plugged status before reboot |
| @param plugged_after: a boolean, plugged status after reboot |
| |
| """ |
| |
| boot_id = self.host.get_boot_id() |
| self.chameleon_port.set_plug(plugged_before) |
| logging.debug('Reboot...') |
| self.host.reboot(wait=False) |
| time.sleep(self.WAIT_TIME) |
| self.host.test_wait_for_shutdown(self.REBOOT_TIMEOUT) |
| self.host.test_wait_for_boot(boot_id) |
| self.chameleon_port.set_plug(plugged_after) |
| |
| |
| def test_suspend_resume(self, plugged_before_suspend, |
| plugged_after_suspend, plugged_after_resume): |
| """Suspends and resumes the DUT with different connections status |
| before suspend, after suspend, and after resume |
| |
| @param plugged_before_suspend: a boolean, plugged before suspend |
| @param plugged_after_suspend: a boolean, plugged after suspend |
| @param plugged_after_resume: a boolean, plugged after resume |
| |
| """ |
| boot_id = self.host.get_boot_id() |
| # Plug before suspend |
| self.chameleon_port.set_plug(plugged_before_suspend) |
| time.sleep(self.WAIT_TIME) |
| logging.debug('Going to suspend, for %d seconds...', |
| self.SUSPEND_DURATION) |
| time_before_suspend = time.time() |
| self.display_facade.suspend_resume_bg(self.SUSPEND_DURATION) |
| |
| # Confirm DUT suspended. |
| self.host.test_wait_for_sleep(self.SUSPEND_TIMEOUT) |
| if plugged_before_suspend is not plugged_after_suspend: |
| self.chameleon_port.set_plug(plugged_after_suspend) |
| |
| current_time = time.time() |
| sleep_time = (self.SUSPEND_DURATION - |
| (current_time - time_before_suspend)) |
| logging.debug('Wait for %.2f seconds...', sleep_time) |
| time.sleep(sleep_time) |
| |
| self.host.test_wait_for_resume(boot_id, self.RESUME_TIMEOUT) |
| logging.debug('Resumed ') |
| |
| if plugged_after_resume is not plugged_after_suspend: |
| self.chameleon_port.set_plug(plugged_after_resume) |
| |
| |
| def check_external_display(self): |
| """Display status check""" |
| # Check connector and test image |
| if self.screen_test.check_external_display_connected( |
| self.connector_used, self.errors) is None: |
| self.screen_test.test_screen_with_image( |
| self.resolution, self.test_mirrored, self.errors) |
| # Check for crashes. |
| if self.is_crash_data_present(): |
| self.errors.append('Crash data is detected on DUT') |
| # Check for errors |
| if self.errors: |
| raise error.TestFail('; '.join(set(self.errors))) |
| |
| |
| def get_edids_filepaths(self): |
| """Gets the EDID data files for the connector type used""" |
| if self.connector_used.startswith('HDMI'): |
| first_edid,second_edid = self.EDID_FILE_NAMES[0] |
| elif self.connector_used.startswith('DP'): |
| first_edid,second_edid = self.EDID_FILE_NAMES[1] |
| first_edid = os.path.join(self.bindir, 'test_data/edids', first_edid) |
| second_edid = os.path.join(self.bindir, 'test_data/edids', second_edid) |
| return (first_edid, second_edid) |
| |
| |
| def check_external_resolution(self): |
| """Checks the external screen resolution.""" |
| # Wait video stable, making sure CrOS switches to a proper resolution. |
| self.chameleon_port.wait_video_input_stable() |
| # Get the resolution for the edid applied |
| self.resolution = utils.wait_for_value_changed( |
| self.display_facade.get_external_resolution, |
| old_value=self.resolution) |
| if self.resolution is None: |
| self.resolution = utils.wait_for_value_changed( |
| self.display_facade.get_external_resolution, |
| old_value=None) |
| if self.resolution is None: |
| raise error.TestFail('No external display detected on DUT') |
| |
| logging.debug('External display resolution: %dx%d', *self.resolution) |
| |
| |
| def apply_edid(self, edid_file): |
| """Apply EDID from a file |
| |
| @param edid_file: file path to edid data |
| |
| """ |
| self.display_facade.apply_edid(edid.Edid.from_file(edid_file)) |
| |
| |
| def dock_dut(self): |
| """Close lid(assumes device is connected to chameleon)""" |
| board = self.host.get_board().split(':')[1] |
| logging.debug('Docking the DUT!') |
| if board not in self.NO_LID_BOARDS: |
| self.host.servo.lid_close() |
| time.sleep(self.WAIT_TIME) |
| return True |
| else: |
| logging.debug('DUT does not dock!') |
| return False |
| |
| |
| def undock_dut(self): |
| """Open the lid""" |
| self.host.servo.lid_open() |
| time.sleep(self.WAIT_TIME) |
| |
| |
| def run_once(self, host, test_mirrored=False): |
| self.host = host |
| self.test_mirrored = test_mirrored |
| self.errors = [] |
| self.resolution = None |
| |
| # Check the servo object |
| if self.host.servo is None: |
| raise error.TestError('Invalid servo object found on the host.') |
| |
| # Remove any crash data before test procedure |
| if self.is_crash_data_present(): |
| self.remove_crash_data() |
| |
| factory = remote_facade_factory.RemoteFacadeFactory(host) |
| display_facade = factory.create_display_facade() |
| chameleon_board = host.chameleon |
| |
| chameleon_board.reset() |
| finder = chameleon_port_finder.ChameleonVideoInputFinder( |
| chameleon_board, display_facade) |
| for chameleon_port in finder.iterate_all_ports(): |
| self.run_test_on_port(chameleon_port, display_facade) |
| |
| |
| def run_test_on_port(self, chameleon_port, display_facade): |
| """Run the test on the given Chameleon port. |
| |
| @param chameleon_port: a ChameleonPorts object. |
| @param display_facade: a display facade object. |
| """ |
| self.chameleon_port = chameleon_port |
| self.display_facade = display_facade |
| self.screen_test = chameleon_screen_test.ChameleonScreenTest( |
| chameleon_port, display_facade, self.outputdir) |
| |
| self.connector_used = self.display_facade.get_external_connector_name() |
| first_edid, second_edid = self.get_edids_filepaths() |
| |
| # Set first monitor/EDID and tracked resolution |
| with self.chameleon_port.use_edid_file(first_edid): |
| self.check_external_resolution() |
| # Set main display mode for the test |
| logging.debug('Set mirrored: %s', self.test_mirrored) |
| self.display_facade.set_mirrored(self.test_mirrored) |
| |
| logging.debug('- Stage 1 - reboot') |
| # Reboot the device as connected and login |
| self.reboot_device(plugged_before=True, plugged_after=True) |
| # Check status |
| self.check_external_display() |
| |
| logging.debug('- Stage 2 - dock-undock-switch mode and back') |
| # Dock and undock (close lid and open lid) |
| if self.dock_dut(): |
| self.undock_dut(); |
| |
| # Switch mode |
| self.switch_display_mode() |
| # Switch mode back |
| self.switch_display_mode() |
| self.check_external_display() |
| |
| # Suspend and resume as currently plugged |
| logging.debug('- Stage 3 - suspend-resume') |
| self.test_suspend_resume(plugged_before_suspend=True, |
| plugged_after_suspend=True, |
| plugged_after_resume=True) |
| |
| # Check status |
| self.check_external_display() |
| |
| logging.debug('- Stage 4 - unplug-suspend-plug-resume') |
| # Unplug-Suspend-Plug-Resume |
| self.test_suspend_resume(plugged_before_suspend=False, |
| plugged_after_suspend=True, |
| plugged_after_resume=True) |
| # Check status |
| self.check_external_display() |
| |
| logging.debug('- Stage 5 - suspend-unplug-resume-plug') |
| # Suspens-Unplug-Resume-Plug |
| self.test_suspend_resume(plugged_before_suspend=True, |
| plugged_after_suspend=False, |
| plugged_after_resume=True) |
| # Check status |
| self.check_external_display() |
| |
| logging.debug('- Stage 6 - dock-unplug1/suspend-plug2-undock') |
| # Docked mode(close lid) |
| if self.dock_dut(): |
| logging.debug('Unplug display') |
| # Unplug, thus DUT should suspend |
| self.chameleon_port.set_plug(False) |
| self.host.test_wait_for_sleep(self.SUSPEND_TIMEOUT) |
| logging.debug('DUT is suspended') |
| |
| # Plug the second monitor while suspended |
| with self.chameleon_port.use_edid_file(second_edid): |
| self.chameleon_port.set_plug(True) |
| |
| # Resume(open lid), doesn't hurt if DUT is not docked |
| self.undock_dut() |
| self.host.wait_up(self.RESUME_TIMEOUT) |
| |
| # Set mode back to mirror after resuming with diff monitor |
| if self.test_mirrored: |
| self.switch_display_mode() |
| else: |
| # Update the resolution |
| self.check_external_resolution() |
| |
| # Check status |
| self.check_external_display() |
| |
| logging.debug('- Stage 7 - unplug2-plug1') |
| # Unplug and plug the original monitor |
| self.chameleon_port.set_plug(False) |
| |
| with self.chameleon_port.use_edid_file(first_edid): |
| self.chameleon_port.set_plug(True) |
| |
| # Update the resolution |
| self.check_external_resolution() |
| |
| # Check status |
| self.check_external_display() |
