| # Copyright (c) 2012 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. |
| import glob |
| import logging |
| import os |
| import time |
| |
| from autotest_lib.client.bin import test |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib.cros import chrome |
| from autotest_lib.client.cros.graphics import graphics_utils |
| from autotest_lib.client.cros.image_comparison import pdiff_image_comparer |
| from autotest_lib.client.cros.input_playback import input_playback |
| |
| def get_percent_difference(file1, file2): |
| """ |
| Performs pixel comparison of two files, given by their paths |file1| |
| and |file2| using terminal tool 'perceptualdiff' and returns percentage |
| difference of the total file size. |
| |
| @param file1: path to image |
| @param file2: path to secondary image |
| @return: percentage difference of total file size. |
| @raise ValueError: if image dimensions are not the same |
| @raise OSError: if file does not exist or cannot be opened. |
| |
| """ |
| # Using pdiff image comparer to compare the two images. This class |
| # invokes the terminal tool perceptualdiff. |
| pdi = pdiff_image_comparer.PdiffImageComparer() |
| diff_bytes = pdi.compare(file1, file2)[0] |
| return round(100. * diff_bytes / os.path.getsize(file1)) |
| |
| |
| class graphics_VTSwitch(test.test): |
| """ |
| Verify that VT switching works. |
| """ |
| version = 2 |
| GSC = None |
| _WAIT = 5 |
| # TODO(crosbug.com/36417): Need to handle more than one display screen. |
| |
| def initialize(self): |
| self.GSC = graphics_utils.GraphicsStateChecker() |
| self._player = input_playback.InputPlayback() |
| self._player.emulate(input_type='keyboard') |
| self._player.find_connected_inputs() |
| |
| def _open_vt2(self): |
| """Use keyboard shortcut to open VT2.""" |
| self._player.blocking_playback_of_default_file( |
| input_type='keyboard', filename='keyboard_ctrl+alt+f2') |
| time.sleep(self._WAIT) |
| |
| def _open_vt1(self): |
| """Use keyboard shortcut to close VT2.""" |
| self._player.blocking_playback_of_default_file( |
| input_type='keyboard', filename='keyboard_ctrl+alt+f1') |
| time.sleep(self._WAIT) |
| |
| def run_once(self, |
| num_iterations=2, |
| similarity_percent_threshold=95, |
| difference_percent_threshold=5): |
| |
| # Check for chromebook type devices |
| if not utils.get_board_type() == 'CHROMEBOOK': |
| raise error.TestNAError('DUT is not Chromebook. Test Skipped.') |
| |
| self._num_errors = 0 |
| keyvals = {} |
| |
| # Make sure we start in VT1. |
| self._open_vt1() |
| |
| with chrome.Chrome(): |
| |
| # Take screenshot of browser. |
| vt1_screenshot = self._take_current_vt_screenshot(1) |
| |
| keyvals['num_iterations'] = num_iterations |
| |
| # Go to VT2 and take a screenshot. |
| self._open_vt2() |
| vt2_screenshot = self._take_current_vt_screenshot(2) |
| |
| # Make sure VT1 and VT2 are sufficiently different. |
| diff = get_percent_difference(vt1_screenshot, vt2_screenshot) |
| keyvals['percent_initial_VT1_VT2_difference'] = diff |
| if not diff >= difference_percent_threshold: |
| self._num_errors += 1 |
| logging.error('VT1 and VT2 screenshots only differ by ' + \ |
| '%d %%: %s vs %s' % |
| (diff, vt1_screenshot, vt2_screenshot)) |
| |
| num_identical_vt1_screenshots = 0 |
| num_identical_vt2_screenshots = 0 |
| max_vt1_difference_percent = 0 |
| max_vt2_difference_percent = 0 |
| |
| # Repeatedly switch between VT1 and VT2. |
| for iteration in xrange(num_iterations): |
| logging.info('Iteration #%d', iteration) |
| |
| # Go to VT1 and take a screenshot. |
| self._open_vt1() |
| current_vt1_screenshot = self._take_current_vt_screenshot(1) |
| |
| # Make sure the current VT1 screenshot is the same as (or similar |
| # to) the original login screen screenshot. |
| diff = get_percent_difference(vt1_screenshot, |
| current_vt1_screenshot) |
| if not diff < similarity_percent_threshold: |
| max_vt1_difference_percent = \ |
| max(diff, max_vt1_difference_percent) |
| self._num_errors += 1 |
| logging.error('VT1 screenshots differ by %d %%: %s vs %s', |
| diff, vt1_screenshot, |
| current_vt1_screenshot) |
| else: |
| num_identical_vt1_screenshots += 1 |
| |
| # Go to VT2 and take a screenshot. |
| self._open_vt2() |
| current_vt2_screenshot = self._take_current_vt_screenshot(2) |
| |
| # Make sure the current VT2 screenshot is the same as (or |
| # similar to) the first VT2 screenshot. |
| diff = get_percent_difference(vt2_screenshot, |
| current_vt2_screenshot) |
| if not diff <= similarity_percent_threshold: |
| max_vt2_difference_percent = \ |
| max(diff, max_vt2_difference_percent) |
| self._num_errors += 1 |
| logging.error( |
| 'VT2 screenshots differ by %d %%: %s vs %s', |
| diff, vt2_screenshot, current_vt2_screenshot) |
| else: |
| num_identical_vt2_screenshots += 1 |
| |
| self._open_vt1() |
| |
| keyvals['percent_VT1_screenshot_max_difference'] = \ |
| max_vt1_difference_percent |
| keyvals['percent_VT2_screenshot_max_difference'] = \ |
| max_vt2_difference_percent |
| keyvals['num_identical_vt1_screenshots'] = num_identical_vt1_screenshots |
| keyvals['num_identical_vt2_screenshots'] = num_identical_vt2_screenshots |
| |
| self.write_perf_keyval(keyvals) |
| |
| if self._num_errors > 0: |
| raise error.TestFail('Failed: saw %d VT switching errors.' % |
| self._num_errors) |
| |
| def _take_current_vt_screenshot(self, current_vt): |
| """ |
| Captures a screenshot of the current VT screen in BMP format. |
| |
| @param current_vt: desired vt for screenshot. |
| |
| @returns the path of the screenshot file. |
| |
| """ |
| extension = 'bmp' |
| |
| # In VT1, X is running so use that screenshot function. |
| if current_vt == 1: |
| return graphics_utils.take_screenshot(self.resultsdir, |
| 'graphics_VTSwitch_VT1', |
| extension) |
| |
| # Otherwise, take a screenshot using screenshot.py. |
| prefix = 'graphics_VTSwitch_VT2' |
| next_index = len(glob.glob( |
| os.path.join(self.resultsdir, '%s-*.%s' % (prefix, extension)))) |
| filename = '%s-%d.%s' % (prefix, next_index, extension) |
| output_path = os.path.join(self.resultsdir, filename) |
| return self._take_screenshot(output_path) |
| |
| def _take_screenshot(self, output_path): |
| """ |
| Takes screenshot. |
| |
| @param output_path: screenshot output path. |
| |
| @returns output_path where screenshot was saved. |
| |
| """ |
| screenshot_path = os.path.join(self.autodir, 'bin', 'screenshot.py') |
| utils.system('%s %s' % (screenshot_path, output_path), |
| ignore_status=True) |
| utils.system('sync', ignore_status=True) |
| time.sleep(self._WAIT) |
| logging.info('Saving screenshot to %s', output_path) |
| return output_path |
| |
| def cleanup(self): |
| # Return to VT1 when done. Ideally, the screen should already be in VT1 |
| # but the test might fail and terminate while in VT2. |
| self._open_vt1() |
| if self.GSC: |
| self.GSC.finalize() |
| self._player.close() |
