Merge lp:~elopio/autopilot/fix1201057-pep8-8 into lp:autopilot

[Leo Arias]

Fixed pep8 errors in the autopilot folder.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:300
http://jenkins.qa.ubuntu.com/job/autopilot-ci/166/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-amd64-ci/94
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-saucy-armhf-ci/94

Click here to trigger a rebuild:
http://s-jenkins:8080/job/autopilot-ci/166/rebuild

review: Approve (continuous-integration)

[Thomi Richards (thomir-deactivatedaccount)]

LGTM

review: Approve

=== modified file 'autopilot/__init__.py'
--- autopilot/__init__.py	2013-07-04 08:24:55 +0000
+++ autopilot/__init__.py	2013-07-22 04:44:44 +0000
@@ -29,9 +29,8 @@
 
     def __init__(self, original_exception):
         super(BackendException, self).__init__(
-            "Error while initialising backend. Original exception was: " \
-            + original_exception.message
-            )
+            "Error while initialising backend. Original exception was: " +
+            original_exception.message)
         self.original_exception = original_exception
 
 
@@ -70,49 +69,51 @@
     parser_run.add_argument("-ro", "--random-order", action='store_true',
                             required=False, default=False,
                             help="Run the tests in random order")
-    parser_run.add_argument('-v', '--verbose', default=False, required=False,
-                            action='count',
-                            help="If set, autopilot will output test log data \
-                            to stderr during a test run. Set twice to also log \
-                            data useful for debugging autopilot itself.")
+    parser_run.add_argument(
+        '-v', '--verbose', default=False, required=False, action='count',
+        help="If set, autopilot will output test log data to stderr during a "
+        "test run. Set twice to also log data useful for debugging autopilot "
+        "itself.")
     parser_run.add_argument("suite", nargs="+",
                             help="Specify test suite(s) to run.")
 
     parser_list = subparsers.add_parser('list', help="List autopilot tests")
-    parser_list.add_argument("-ro", "--run-order", required=False, default=False,
-                            action="store_true",
-                            help="List tests in run order, rather than alphabetical \
-                            order (the default).")
-    parser_list.add_argument("--suites", required=False, action='store_true',
-                             help="Lists only available suites, not tests contained \
-                             within the suite.")
+    parser_list.add_argument(
+        "-ro", "--run-order", required=False, default=False,
+        action="store_true",
+        help="List tests in run order, rather than alphabetical order (the "
+        "default).")
+    parser_list.add_argument(
+        "--suites", required=False, action='store_true',
+        help="Lists only available suites, not tests contained within the "
+        "suite.")
     parser_list.add_argument("suite", nargs="+",
                              help="Specify test suite(s) to run.")
 
     if have_vis():
-        parser_vis = subparsers.add_parser('vis',
-                                          help="Open the Autopilot visualiser tool")
-        parser_vis.add_argument('-v', '--verbose', required=False, default=False,
-                                action='count', help="Show autopilot log messages. \
-                                Set twice to also log data useful for debugging \
-                                autopilot itself.")
+        parser_vis = subparsers.add_parser(
+            'vis', help="Open the Autopilot visualiser tool")
+        parser_vis.add_argument(
+            '-v', '--verbose', required=False, default=False, action='count',
+            help="Show autopilot log messages. Set twice to also log data "
+            "useful for debugging autopilot itself.")
 
-    parser_launch = subparsers.add_parser('launch',
-                            help="Launch an application with introspection enabled")
-    parser_launch.add_argument('-i', '--interface',
-                            choices=('Gtk', 'Qt', 'Auto'), default='Auto',
-                            help="Specify which introspection interface to load. \
-                            The default ('Auto') uses ldd to try and detect which \
-                            interface to load.")
-    parser_launch.add_argument('-v', '--verbose', required=False, default=False,
-                            action='count', help="Show autopilot log messages. \
-                            Set twice to also log data useful for debugging \
-                            autopilot itself.")
-    parser_launch.add_argument('application', action=_OneOrMoreArgumentStoreAction,
-                            type=str, nargs=REMAINDER,
-                            help="The application to launch. Can be a full path, \
-                            or just an application name (in which case Autopilot \
-                                will search for it in $PATH).")
+    parser_launch = subparsers.add_parser(
+        'launch', help="Launch an application with introspection enabled")
+    parser_launch.add_argument(
+        '-i', '--interface', choices=('Gtk', 'Qt', 'Auto'), default='Auto',
+        help="Specify which introspection interface to load. The default"
+        "('Auto') uses ldd to try and detect which interface to load.")
+    parser_launch.add_argument(
+        '-v', '--verbose', required=False, default=False, action='count',
+        help="Show autopilot log messages. Set twice to also log data useful "
+        "for debugging autopilot itself.")
+    parser_launch.add_argument(
+        'application', action=_OneOrMoreArgumentStoreAction, type=str,
+        nargs=REMAINDER,
+        help="The application to launch. Can be a full path, or just an "
+        "application name (in which case Autopilot will search for it in "
+        "$PATH).")
     args = parser.parse_args(args=argv)
 
     return args
@@ -122,7 +123,8 @@
 
     def __call__(self,  parser, namespace, values, option_string=None):
         if len(values) == 0:
-            parser.error("Must specify at least one argument to the 'launch' command")
+            parser.error(
+                "Must specify at least one argument to the 'launch' command")
         setattr(namespace, self.dest, values)
 
 
@@ -159,13 +161,14 @@
 
 
 def _running_in_system():
-    """Return True if we're running autopilot from the system installation dir."""
+    """Return True if we're running autopilot from the system installation
+    dir."""
     return __file__.startswith('/usr/')
 
 
 def _get_package_installed_version():
-    """Get the version string of the system-wide installed package, or None if it
-    is not installed.
+    """Get the version string of the system-wide installed package, or None if
+    it is not installed.
 
     """
     try:
@@ -176,7 +179,7 @@
                 "${Version}",
                 "--show",
                 "python-autopilot",
-                ]
-            ).strip()
+            ]
+        ).strip()
     except subprocess.CalledProcessError:
         return None

=== modified file 'autopilot/clipboard.py'
--- autopilot/clipboard.py	2013-07-19 07:03:40 +0000
+++ autopilot/clipboard.py	2013-07-22 04:44:44 +0000
@@ -24,8 +24,8 @@
 def get_clipboard_contents():
     """Get the contents of the clipboard.
 
-    This function returns the text copied to the 'CLIPBOARD' clipboard. Text can
-    be added to this clipbaord using Ctrl+C.
+    This function returns the text copied to the 'CLIPBOARD' clipboard. Text
+    can be added to this clipbaord using Ctrl+C.
 
     """
     from gi import require_version

=== modified file 'autopilot/dbus_handler.py'
--- autopilot/dbus_handler.py	2013-05-02 16:29:44 +0000
+++ autopilot/dbus_handler.py	2013-07-22 04:44:44 +0000
@@ -26,6 +26,7 @@
 import dbus
 from dbus.mainloop.glib import DBusGMainLoop
 
+
 _glib_loop_set = False
 
 # DBus has an annoying bug where we need to initialise it with the gobject main
@@ -65,4 +66,3 @@
     """
     _ensure_glib_loop_set()
     return BusConnection(bus_address)
-

=== modified file 'autopilot/emulators.py'
--- autopilot/emulators.py	2013-04-27 05:23:05 +0000
+++ autopilot/emulators.py	2013-07-22 04:44:44 +0000
@@ -21,12 +21,12 @@
 """
 .. otto:: **Deprecated Namespace!**
 
-    This module contains modules that were in the ``autopilot.emulators`` package in
-    autopilot version 1.2 and earlier, but have now been moved to the ``autopilot``
-    package.
+    This module contains modules that were in the ``autopilot.emulators``
+    package in autopilot version 1.2 and earlier, but have now been moved to
+    the ``autopilot`` package.
 
-    This module exists to ease the transition to autopilot 1.3, but is not guaranteed
-    to exist in the future.
+    This module exists to ease the transition to autopilot 1.3, but is not
+    guaranteed to exist in the future.
 
     .. seealso::
 
@@ -42,5 +42,3 @@
 import autopilot.dbus_handler as dbus_handler
 import autopilot.ibus as ibus
 import autopilot.input as input
-
-

=== modified file 'autopilot/gestures.py'
--- autopilot/gestures.py	2013-04-27 05:23:05 +0000
+++ autopilot/gestures.py	2013-07-22 04:44:44 +0000
@@ -21,8 +21,8 @@
 """Gestural support for autopilot.
 
 This module contains functions that can generate touch and multi-touch gestures
-for you. This is a convenience for the test author - there is nothing to prevent
-you from generating your own gestures!
+for you. This is a convenience for the test author - there is nothing to
+prevent you from generating your own gestures!
 
 """
 
@@ -34,8 +34,10 @@
     """Perform a two finger pinch (zoom) gesture.
 
     :param center: The coordinates (x,y) of the center of the pinch gesture.
-    :param vector_start: The (x,y) values to move away from the center for the start.
-    :param vector_end: The (x,y) values to move away from the center for the end.
+    :param vector_start: The (x,y) values to move away from the center for the
+     start.
+    :param vector_end: The (x,y) values to move away from the center for the
+     end.
 
     The fingers will move in 100 steps between the start and the end points.
     If start is smaller than end, the gesture will zoom in, otherwise it

=== modified file 'autopilot/globals.py'
--- autopilot/globals.py	2013-07-10 02:20:44 +0000
+++ autopilot/globals.py	2013-07-22 04:44:44 +0000
@@ -72,7 +72,8 @@
         root_logger = logging.getLogger()
         self._log_handler.flush()
         self._log_buffer.seek(0)
-        test_instance.addDetail('test-log', text_content(self._log_buffer.getvalue()))
+        test_instance.addDetail(
+            'test-log', text_content(self._log_buffer.getvalue()))
         root_logger.removeHandler(self._log_handler)
         self._log_buffer = None
 
@@ -92,7 +93,7 @@
     """Video capture autopilot tests, saving the results if the test failed."""
 
     _recording_app = '/usr/bin/recordmydesktop'
-    _recording_opts = ['--no-sound', '--no-frame', '-o',]
+    _recording_opts = ['--no-sound', '--no-frame', '-o']
 
     def __init__(self):
         self._enable_recording = False
@@ -100,13 +101,18 @@
 
     def __call__(self, test_instance):
         if not self._have_recording_app():
-            logger.warning("Disabling video capture since '%s' is not present", self._recording_app)
+            logger.warning(
+                "Disabling video capture since '%s' is not present",
+                self._recording_app)
 
         if self._currently_recording_description is not None:
-            logger.warning("Video capture already in progress for %s", self._currently_recording_description)
+            logger.warning(
+                "Video capture already in progress for %s",
+                self._currently_recording_description)
             return
 
-        self._currently_recording_description = test_instance.shortDescription()
+        self._currently_recording_description = \
+            test_instance.shortDescription()
         self._test_passed = True
         test_instance.addOnException(self._on_test_failed)
         test_instance.addCleanup(self._stop_video_capture, test_instance)
@@ -136,7 +142,7 @@
         self._capture_file = os.path.join(
             self.recording_directory,
             '%s.ogv' % (test_id)
-            )
+        )
         self._ensure_directory_exists_but_not_file(self._capture_file)
         args.append(self._capture_file)
         logger.debug("Starting: %r", args)
@@ -144,10 +150,11 @@
             args,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT
-            )
+        )
 
     def _stop_video_capture(self, test_instance):
-        """Stop the video capture. If the test failed, save the resulting file."""
+        """Stop the video capture. If the test failed, save the resulting
+        file."""
 
         if self._test_passed:
             # We use kill here because we don't want the recording app to start
@@ -158,7 +165,9 @@
             self._capture_process.terminate()
             self._capture_process.wait()
             if self._capture_process.returncode != 0:
-                test_instance.addDetail('video capture log', text_content(self._capture_process.stdout.read()))
+                test_instance.addDetail(
+                    'video capture log',
+                    text_content(self._capture_process.stdout.read()))
         self._capture_process = None
         self._currently_recording_description = None
 
@@ -170,7 +179,8 @@
         if not os.path.exists(dirpath):
             os.makedirs(dirpath)
         elif os.path.exists(file_path):
-            logger.warning("Video capture file '%s' already exists, deleting.", file_path)
+            logger.warning(
+                "Video capture file '%s' already exists, deleting.", file_path)
             os.remove(file_path)
 
     def _on_test_failed(self, ex_info):
@@ -199,4 +209,3 @@
     _video_logger.enable_recording(enable_recording)
     _video_logger.set_recording_dir(record_dir)
     _video_logger.set_recording_opts(record_opts)
-

=== modified file 'autopilot/ibus.py'
--- autopilot/ibus.py	2013-04-23 04:15:54 +0000
+++ autopilot/ibus.py	2013-07-22 04:44:44 +0000
@@ -54,7 +54,8 @@
     main_loop.run()
 
     if not bus.is_connected():
-        raise RuntimeError("Could not start ibus-daemon after %d seconds." % (timeout))
+        raise RuntimeError(
+            "Could not start ibus-daemon after %d seconds." % (timeout))
     return bus
 
 
@@ -79,9 +80,9 @@
 
     .. note:: This function removes all other engines.
 
-    This function returns the list of engines installed before this function was
-    called. The caller should pass this list to set_active_engines to restore
-    ibus to it's old state once the test has finished.
+    This function returns the list of engines installed before this function
+    was called. The caller should pass this list to set_active_engines to
+    restore ibus to it's old state once the test has finished.
 
     :param engine_list: List of engine names
     :type engine_list: List of strings
@@ -96,7 +97,8 @@
         if not isinstance(engine, basestring):
             raise TypeError("Engines in engine_list must all be strings.")
         if engine not in available_engines:
-            raise ValueError("engine_list contains invalid engine name: '%s'", engine)
+            raise ValueError(
+                "engine_list contains invalid engine name: '%s'", engine)
 
     bus = get_ibus_bus()
     config = bus.get_config()
@@ -106,20 +108,18 @@
                      GLib.Variant.new_int32(IBus.PreloadEngineMode.USER))
 
     old_engines = get_active_input_engines()
-    config.set_value("general",
-                    "preload_engines",
-                    GLib.Variant("as", engine_list)
-                    )
+    config.set_value(
+        "general", "preload_engines", GLib.Variant("as", engine_list))
     # need to restart the ibus bus before it'll pick up the new engine.
     # see bug report here:
-    # http://code.google.com/p/ibus/issues/detail?id=1418&thanks=1418&ts=1329885137
+    # http://code.google.com/p/ibus/issues/detail?id=1418
     bus.exit(restart=True)
     return old_engines
 
 
 def set_gconf_option(path, value):
     """Set the gconf setting on `path` to the defined `value`"""
-    _set_gconf_list (path, value)
+    _set_gconf_list(path, value)
 
 
 def get_gconf_option(path):
@@ -131,7 +131,9 @@
 
 def _set_gconf_list(path, values):
     gconf_value = '[%s]' % ','.join(values)
-    subprocess.check_output(["gconftool-2", "--set", "--type=list", "--list-type=string", path, gconf_value])
+    subprocess.check_output(
+        ["gconftool-2", "--set", "--type=list", "--list-type=string", path,
+         gconf_value])
 
 
 def _get_native_gconf_value(value):

=== modified file 'autopilot/keybindings.py'
--- autopilot/keybindings.py	2013-04-23 04:15:54 +0000
+++ autopilot/keybindings.py	2013-07-22 04:44:44 +0000
@@ -21,8 +21,8 @@
 """Utility functions to get shortcut keybindings for various parts of Unity.
 
 Inside Autopilot we deal with keybindings by naming them with unique names. For
-example, instead of hard-coding the fact that 'Alt+F2' opens the command lens, we
-might call:
+example, instead of hard-coding the fact that 'Alt+F2' opens the command lens,
+we might call:
 
 >>> keybindings.get('lens_reveal/command')
 'Alt+F2'
@@ -117,7 +117,7 @@
     "workspace/move_up": ("wall", "up_key"),
     "workspace/move_down": ("wall", "down_key"),
     # Window management:
-    "window/show_desktop" : ("core", "show_desktop_key"),
+    "window/show_desktop": ("core", "show_desktop_key"),
     "window/minimize": ("core", "minimize_window_key"),
     "window/maximize": ("core", "maximize_window_key"),
     "window/restore": ("core", "unmaximize_or_minimize_window_key"),
@@ -131,7 +131,6 @@
 }
 
 
-
 def get(binding_name):
     """Get a keybinding, given its well-known name.
 
@@ -154,8 +153,8 @@
 def get_hold_part(binding_name):
     """Returns the part of a keybinding that must be held permanently.
 
-    Use this function to split bindings like "Alt+Tab" into the part that must be
-    held down. See :meth:`get_tap_part` for the part that must be tapped.
+    Use this function to split bindings like "Alt+Tab" into the part that must
+    be held down. See :meth:`get_tap_part` for the part that must be tapped.
 
     :raises: **ValueError** if the binding specified does not have multiple
      parts.
@@ -164,7 +163,8 @@
     binding = get(binding_name)
     parts = binding.split('+')
     if len(parts) == 1:
-        logger.warning("Key binding '%s' does not have a hold part.", binding_name)
+        logger.warning(
+            "Key binding '%s' does not have a hold part.", binding_name)
         return parts[0]
     return '+'.join(parts[:-1])
 
@@ -172,8 +172,9 @@
 def get_tap_part(binding_name):
     """Returns the part of a keybinding that must be tapped.
 
-    Use this function to split bindings like "Alt+Tab" into the part that must be
-    held tapped. See :meth:`get_hold_part` for the part that must be held down.
+    Use this function to split bindings like "Alt+Tab" into the part that must
+    be held tapped. See :meth:`get_hold_part` for the part that must be held
+    down.
 
     :Raises: **ValueError** if the binding specified does not have multiple
      parts.
@@ -182,13 +183,15 @@
     binding = get(binding_name)
     parts = binding.split('+')
     if len(parts) == 1:
-        logger.warning("Key binding '%s' does not have a tap part.", binding_name)
+        logger.warning(
+            "Key binding '%s' does not have a tap part.", binding_name)
         return parts[0]
     return parts[-1]
 
 
 def _get_compiz_keybinding(compiz_tuple):
-    """Given a keybinding name, get the keybinding string from the compiz option.
+    """Given a keybinding name, get the keybinding string from the compiz
+    option.
 
     :raises: **ValueError** if the compiz setting described does not hold a
      keybinding.
@@ -199,13 +202,17 @@
     plugin = _get_compiz_plugin(plugin_name)
     setting = _get_compiz_setting(plugin_name, setting_name)
     if setting.Type != 'Key':
-        raise ValueError("Key binding maps to a compiz option that does not hold a keybinding.")
+        raise ValueError(
+            "Key binding maps to a compiz option that does not hold a "
+            "keybinding.")
     if not plugin.Enabled:
-        logger.warning("Returning keybinding for '%s' which is in un-enabled plugin '%s'",
+        logger.warning(
+            "Returning keybinding for '%s' which is in un-enabled plugin '%s'",
             setting.ShortDesc,
             plugin.ShortDesc)
     if setting.Value == "Disabled":
-        raise RuntimeError("Keybinding '%s' in compiz plugin '%s' has been disabled." %
+        raise RuntimeError(
+            "Keybinding '%s' in compiz plugin '%s' has been disabled." %
             (setting.ShortDesc, plugin.ShortDesc))
 
     return _translate_compiz_keystroke_string(setting.Value)
@@ -254,7 +261,8 @@
 
         """
         if type(delay) not in (float, NoneType):
-            raise TypeError("delay parameter must be a float if it is defined.")
+            raise TypeError(
+                "delay parameter must be a float if it is defined.")
         if delay:
             self._keyboard.press_and_release(get(binding_name), delay)
         else:
@@ -282,6 +290,7 @@
 # future.
 _global_compiz_context = None
 
+
 def _get_global_compiz_context():
     """Get the compizconfig global context object."""
     global _global_compiz_context
@@ -303,7 +312,8 @@
         try:
             return ctx.Plugins[plugin_name]
         except KeyError:
-            raise KeyError("Compiz plugin '%s' does not exist." % (plugin_name))
+            raise KeyError(
+                "Compiz plugin '%s' does not exist." % (plugin_name))
 
 
 def _get_compiz_setting(plugin_name, setting_name):
@@ -317,6 +327,6 @@
         try:
             return plugin.Screen[setting_name]
         except KeyError:
-            raise KeyError("Compiz setting '%s' does not exist in plugin '%s'." % (setting_name, plugin_name))
-
-
+            raise KeyError(
+                "Compiz setting '%s' does not exist in plugin '%s'." %
+                (setting_name, plugin_name))

=== modified file 'autopilot/platform.py'
--- autopilot/platform.py	2013-04-27 05:00:37 +0000
+++ autopilot/platform.py	2013-07-22 04:44:44 +0000
@@ -22,9 +22,10 @@
 Platform identification utilities for Autopilot.
 ================================================
 
-This module provides functions that give test authors hints as to which platform
-their tests are currently running on. This is useful when a test needs to test
-slight different behavior depending on the system it's running on. For example::
+This module provides functions that give test authors hints as to which
+platform their tests are currently running on. This is useful when a test
+needs to test slight different behavior depending on the system it's running
+on. For example::
 
     from autopilot import platform
 
@@ -39,10 +40,11 @@
 Skipping tests based on Platform
 ++++++++++++++++++++++++++++++++
 
-Sometimes you want a test to not run on certain platforms, or only run on certain
-platforms. This can be easily achieved with a combination of the functions in this
-module and the ``skipIf`` and ``skipUnless`` decorators. For example, to define
-a test that only runs on the galaxy nexus device, write this::
+Sometimes you want a test to not run on certain platforms, or only run on
+certain platforms. This can be easily achieved with a combination of the
+functions in this module and the ``skipIf`` and ``skipUnless`` decorators. For
+example, to define a test that only runs on the galaxy nexus device, write
+this::
 
     from testtools import skipUnless
 
@@ -109,7 +111,8 @@
 
     @staticmethod
     def create():
-        """Create a platform detector object, or return one we baked earlier."""
+        """Create a platform detector object, or return one we baked
+        earlier."""
         if _PlatformDetector._cached_detector is None:
             _PlatformDetector._cached_detector = _PlatformDetector()
         return _PlatformDetector._cached_detector
@@ -130,8 +133,8 @@
 
 
 def _get_property_file():
-    """Return a file-like object that contains the contents of the build properties
-    file, if it exists, or None.
+    """Return a file-like object that contains the contents of the build
+    properties file, if it exists, or None.
 
     """
     if exists('/system/build.prop'):
@@ -159,4 +162,3 @@
 
         properties[key] = value
     return properties
-

=== modified file 'autopilot/testcase.py'
--- autopilot/testcase.py	2013-05-30 12:00:24 +0000
+++ autopilot/testcase.py	2013-07-22 04:44:44 +0000
@@ -22,17 +22,17 @@
 Quick Start
 ===========
 
-The :class:`AutopilotTestCase` is the main class test authors will be interacting
-with. Every autopilot test case should derive from this class.
+The :class:`AutopilotTestCase` is the main class test authors will be
+interacting with. Every autopilot test case should derive from this class.
 :class:`AutopilotTestCase` derives from :class:`testtools.TestCase`, so test
 authors can use all the methods defined in that class as well.
 
 **Writing tests**
 
 Tests must be named: ``test_<testname>``, where *<testname>* is the name of the
-test. Test runners (including autopilot itself) look for methods with this naming
-convention. It is recommended that you make your test names descriptive of what
-each test is testing. For example, possible test names include::
+test. Test runners (including autopilot itself) look for methods with this
+naming convention. It is recommended that you make your test names descriptive
+of what each test is testing. For example, possible test names include::
 
     test_ctrl_p_opens_print_dialog
     test_dash_remembers_maximized_state
@@ -66,16 +66,16 @@
     get_application_launcher_from_string_hint,
     get_autopilot_proxy_object_for_process,
     launch_application,
-    )
+)
 from autopilot.display import Display
 from autopilot.utilities import on_test_started
 from autopilot.keybindings import KeybindingsHelper
 from autopilot.matchers import Eventually
 try:
     from autopilot import tracepoint as tp
-    HAVE_TRACEPOINT=True
+    HAVE_TRACEPOINT = True
 except ImportError:
-    HAVE_TRACEPOINT=False
+    HAVE_TRACEPOINT = False
 
 
 logger = logging.getLogger(__name__)
@@ -85,6 +85,7 @@
     from testscenarios.scenarios import multiply_scenarios
 except ImportError:
     from itertools import product
+
     def multiply_scenarios(*scenarios):
         """Multiply two or more iterables of scenarios.
 
@@ -110,7 +111,9 @@
     if HAVE_TRACEPOINT:
         tp.emit_test_started(test_id)
     else:
-        logger.warning("No tracing available - install the python-autopilot-trace package!")
+        logger.warning(
+            "No tracing available - install the python-autopilot-trace "
+            "package!")
 
 
 def _lttng_trace_test_ended(test_id):
@@ -121,9 +124,10 @@
 class AutopilotTestCase(TestWithScenarios, TestCase, KeybindingsHelper):
     """Wrapper around testtools.TestCase that adds significant functionality.
 
-    This class should be the base class for all autopilot test case classes. Not
-    using this class as the base class disables several important convenience
-    methods, and also prevents the use of the failed-test recording tools.
+    This class should be the base class for all autopilot test case classes.
+    Not using this class as the base class disables several important
+    convenience methods, and also prevents the use of the failed-test
+    recording tools.
 
     """
 
@@ -140,10 +144,13 @@
         self._display = None
 
         try:
-            self._app_snapshot = self.process_manager.get_running_applications()
+            self._app_snapshot = \
+                self.process_manager.get_running_applications()
             self.addCleanup(self._compare_system_with_app_snapshot)
         except RuntimeError:
-            logger.warning("Process manager backend unavailable, application snapshot support disabled.")
+            logger.warning(
+                "Process manager backend unavailable, application snapshot "
+                "support disabled.")
 
     @property
     def process_manager(self):
@@ -170,39 +177,45 @@
         return self._display
 
     def launch_test_application(self, application, *arguments, **kwargs):
-        """Launch ``application`` and return a proxy object for the application.
+        """Launch ``application`` and return a proxy object for the
+        application.
 
         Use this method to launch an application and start testing it. The
         positional arguments are used as arguments to the application to lanch.
-        Keyword arguments are used to control the manner in which the application
-        is launched.
+        Keyword arguments are used to control the manner in which the
+        application is launched.
 
         This method is designed to be flexible enough to launch all supported
-        types of applications. Autopilot can automatically determine how to enable
-        introspection support for dynamically linked binary applications. For
-        example, to launch a binary Gtk application, a test might start with::
+        types of applications. Autopilot can automatically determine how to
+        enable introspection support for dynamically linked binary
+        applications. For example, to launch a binary Gtk application, a test
+        might start with::
 
             app_proxy = self.launch_test_application('gedit')
 
-        Applications can be given command line arguments by supplying positional
-        arguments to this method. For example, if we want to launch ``gedit``
-        with a certain document loaded, we might do this::
+        Applications can be given command line arguments by supplying
+        positional arguments to this method. For example, if we want to launch
+        ``gedit`` with a certain document loaded, we might do this::
 
-            app_proxy = self.launch_test_application('gedit', '/tmp/test-document.txt')
+            app_proxy = self.launch_test_application(
+                'gedit', '/tmp/test-document.txt')
 
         ... a Qt5 Qml application is launched in a similar fashion::
 
-            app_proxy = self.launch_test_application('qmlscene', 'my_scene.qml')
+            app_proxy = self.launch_test_application(
+                'qmlscene', 'my_scene.qml')
 
         If you wish to launch an application that is not a dynamically linked
-        binary, you must specify the application type. For example, a Qt4 python
-        application might be launched like this::
+        binary, you must specify the application type. For example, a Qt4
+        python application might be launched like this::
 
-            app_proxy = self.launch_test_application('my_qt_app.py', app_type='qt')
+            app_proxy = self.launch_test_application(
+                'my_qt_app.py', app_type='qt')
 
         Similarly, a python/Gtk application is launched like so::
 
-            app_proxy = self.launch_test_application('my_gtk_app.py', app_type='gtk')
+            app_proxy = self.launch_test_application(
+                'my_gtk_app.py', app_type='gtk')
 
         .. seealso::
 
@@ -212,20 +225,23 @@
         :param application: The application to launch. The application can be
             specified as:
 
-             * A full, absolute path to an executable file. (``/usr/bin/gedit``)
-             * A relative path to an executable file. (``./build/my_app``)
+             * A full, absolute path to an executable file.
+               (``/usr/bin/gedit``)
+             * A relative path to an executable file.
+               (``./build/my_app``)
              * An app name, which will be searched for in $PATH (``my_app``)
 
-        :keyword app_type: If set, provides a hint to autopilot as to which kind
-            of introspection to enable. This is needed when the application you
-            wish to launch is *not* a dynamically linked binary. Valid values are
-            'gtk' or 'qt'. These strings are case insensitive.
-
-        :keyword launch_dir:  If set to a directory that exists the process will be
-            launched from that directory.
-
-        :keyword capture_output: If set to True (the default), the process output
-            will be captured and attached to the test as test detail.
+        :keyword app_type: If set, provides a hint to autopilot as to which
+            kind of introspection to enable. This is needed when the
+            application you wish to launch is *not* a dynamically linked
+            binary. Valid values are 'gtk' or 'qt'. These strings are case
+            insensitive.
+
+        :keyword launch_dir: If set to a directory that exists the process
+            will be launched from that directory.
+
+        :keyword capture_output: If set to True (the default), the process
+            output will be captured and attached to the test as test detail.
 
         :keyword emulator_base: If set, specifies the base class to be used for
             all emulators for this loaded application.
@@ -235,7 +251,7 @@
          data is retrievable via this object.
 
         """
-        app_path = subprocess.check_output(['which',application]).strip()
+        app_path = subprocess.check_output(['which', application]).strip()
         # Get a launcher, tests can override this if they need:
         launcher_hint = kwargs.pop('app_type', '')
         launcher = None
@@ -247,9 +263,10 @@
             except RuntimeError:
                 pass
         if launcher is None:
-            raise RuntimeError("Autopilot could not determine the correct \
-introspection type to use. You can specify one by overriding the \
-AutopilotTestCase.pick_app_launcher method.")
+            raise RuntimeError(
+                "Autopilot could not determine the correct introspection type "
+                "to use. You can specify one by overriding the "
+                "AutopilotTestCase.pick_app_launcher method.")
         emulator_base = kwargs.pop('emulator_base', None)
         process = launch_application(launcher, app_path, *arguments, **kwargs)
         self.addCleanup(self._kill_process_and_attach_logs, process)
@@ -258,8 +275,9 @@
     def _compare_system_with_app_snapshot(self):
         """Compare the currently running application with the last snapshot.
 
-        This method will raise an AssertionError if there are any new applications
-        currently running that were not running when the snapshot was taken.
+        This method will raise an AssertionError if there are any new
+        applications currently running that were not running when the snapshot
+        was taken.
         """
         if self._app_snapshot is None:
             raise RuntimeError("No snapshot to match against.")
@@ -267,19 +285,22 @@
         new_apps = []
         for i in range(10):
             current_apps = self.process_manager.get_running_applications()
-            new_apps = filter(lambda i: i not in self._app_snapshot, current_apps)
+            new_apps = filter(
+                lambda i: i not in self._app_snapshot, current_apps)
             if not new_apps:
                 self._app_snapshot = None
                 return
             sleep(1)
         self._app_snapshot = None
-        raise AssertionError("The following apps were started during the test and not closed: %r", new_apps)
+        raise AssertionError(
+            "The following apps were started during the test and not closed: "
+            "%r", new_apps)
 
     def patch_environment(self, key, value):
         """Patch the process environment, setting *key* with value *value*.
 
-        This patches os.environ for the duration of the test only. After calling
-        this method, the following should be True::
+        This patches os.environ for the duration of the test only. After
+        calling this method, the following should be True::
 
             os.environ[key] == value
 
@@ -290,12 +311,12 @@
          affects the current autopilot process, and any processes spawned by
          autopilot. If you are planing on starting an application from within
          autopilot and you want this new application to read the patched
-         environment variable, you must patch the environment *before* launching
-         the new process.
+         environment variable, you must patch the environment *before*
+         launching the new process.
 
-        :param string key: The name of the key you wish to set. If the key does not
-         already exist in the process environment it will be created (and then
-         deleted when the test ends).
+        :param string key: The name of the key you wish to set. If the key
+         does not already exist in the process environment it will be created
+         (and then deleted when the test ends).
         :param string value: The value you wish to set.
 
         """
@@ -307,7 +328,8 @@
         os.environ[key] = value
 
     def assertVisibleWindowStack(self, stack_start):
-        """Check that the visible window stack starts with the windows passed in.
+        """Check that the visible window stack starts with the windows passed
+        in.
 
         .. note:: Minimised windows are skipped.
 
@@ -317,13 +339,17 @@
          match the contents of the stack_start parameter.
 
         """
-        stack = [win for win in self.process_manager.get_open_windows() if not win.is_hidden]
+        stack = [
+            win for win in
+            self.process_manager.get_open_windows() if not win.is_hidden]
         for pos, win in enumerate(stack_start):
-            self.assertThat(stack[pos].x_id, Equals(win.x_id),
-                            "%r at %d does not equal %r" % (stack[pos], pos, win))
+            self.assertThat(
+                stack[pos].x_id, Equals(win.x_id),
+                "%r at %d does not equal %r" % (stack[pos], pos, win))
 
     def assertProperty(self, obj, **kwargs):
-        """Assert that *obj* has properties equal to the key/value pairs in kwargs.
+        """Assert that *obj* has properties equal to the key/value pairs in
+        kwargs.
 
         This method is intended to be used on objects whose attributes do not
         have the :meth:`wait_for` method (i.e.- objects that do not come from
@@ -352,12 +378,16 @@
             none_val = object()
             attr = getattr(obj, prop_name, none_val)
             if attr == none_val:
-                raise AssertionError("Object %r does not have an attribute named '%s'"
+                raise AssertionError(
+                    "Object %r does not have an attribute named '%s'"
                     % (obj, prop_name))
             if callable(attr):
-                raise ValueError("Object %r's '%s' attribute is a callable. It must be a property."
-                    % (obj, prop_name))
-            self.assertThat(lambda: getattr(obj, prop_name), Eventually(Equals(desired_value)))
+                raise ValueError(
+                    "Object %r's '%s' attribute is a callable. It must be a "
+                    "property." % (obj, prop_name))
+            self.assertThat(
+                lambda: getattr(obj, prop_name),
+                Eventually(Equals(desired_value)))
 
     assertProperties = assertProperty
 
@@ -385,7 +415,9 @@
             if process.returncode is not None:
                 break
             if i == 9:
-                logger.info("Killing process group, since it hasn't exited after 10 seconds.")
+                logger.info(
+                    "Killing process group, since it hasn't exited after 10 "
+                    "seconds.")
                 os.killpg(process.pid, signal.SIGKILL)
             sleep(1)
         stdout, stderr = process.communicate()

=== modified file 'autopilot/testresult.py'
--- autopilot/testresult.py	2013-04-23 04:15:54 +0000
+++ autopilot/testresult.py	2013-07-22 04:44:44 +0000
@@ -27,7 +27,8 @@
 
 
 class AutopilotVerboseResult(object):
-    """A result class that logs failures, errors and success via the python logging framework."""
+    """A result class that logs failures, errors and success via the python
+    logging framework."""
 
     def _log(self, level, message):
         """Performs the actual message logging"""

=== modified file 'autopilot/utilities.py'
--- autopilot/utilities.py	2013-05-30 05:26:34 +0000
+++ autopilot/utilities.py	2013-07-22 04:44:44 +0000
@@ -35,10 +35,12 @@
 def _pick_backend(backends, preferred_backend):
     """Pick a backend and return an instance of it."""
     possible_backends = backends.keys()
-    get_debug_logger().debug("Possible backends: %s", ','.join(possible_backends))
+    get_debug_logger().debug(
+        "Possible backends: %s", ','.join(possible_backends))
     if preferred_backend:
         if preferred_backend in possible_backends:
-            possible_backends.sort(lambda a,b: -1 if a == preferred_backend else 0)
+            possible_backends.sort(
+                lambda a, b: -1 if a == preferred_backend else 0)
         else:
             raise RuntimeError("Unknown backend '%s'" % (preferred_backend))
     failure_reasons = []
@@ -50,10 +52,11 @@
             failure_reasons.append('%s: %r' % (be, e))
             if preferred_backend != '':
                 raise BackendException(e)
-    raise RuntimeError("Unable to instantiate any backends\n%s" % '\n'.join(failure_reasons))
-
-
-# Taken from http://code.activestate.com/recipes/577564-context-manager-for-low-level-redirection-of-stdou/
+    raise RuntimeError(
+        "Unable to instantiate any backends\n%s" % '\n'.join(failure_reasons))
+
+
+# Taken from http://ur1.ca/eqapv
 # licensed under the MIT license.
 class Silence(object):
     """Context manager which uses low-level file descriptors to suppress
@@ -77,7 +80,8 @@
         self.fds = fds = [s.fileno() for s in saved_streams]
         self.saved_fds = map(os.dup, fds)
         # flush any pending output
-        for s in saved_streams: s.flush()
+        for s in saved_streams:
+            s.flush()
 
         # open surrogate files
         if self.combine:
@@ -85,7 +89,8 @@
             if self.outfiles[0] != os.devnull:
                 # disable buffering so output is merged immediately
                 sys.stdout, sys.stderr = map(os.fdopen, fds, ['w']*2, [0]*2)
-        else: null_streams = [open(f, self.mode, 0) for f in self.outfiles]
+        else:
+            null_streams = [open(f, self.mode, 0) for f in self.outfiles]
         self.null_fds = null_fds = [s.fileno() for s in null_streams]
         self.null_streams = null_streams
 
@@ -95,20 +100,24 @@
     def __exit__(self, *args):
         sys = self.sys
         # flush any pending output
-        for s in self.saved_streams: s.flush()
+        for s in self.saved_streams:
+            s.flush()
         # restore original streams and file descriptors
         map(os.dup2, self.saved_fds, self.fds)
         sys.stdout, sys.stderr = self.saved_streams
         # clean up
-        for s in self.null_streams: s.close()
-        for fd in self.saved_fds: os.close(fd)
+        for s in self.null_streams:
+            s.close()
+        for fd in self.saved_fds:
+            os.close(fd)
         return False
 
 
 class LogFormatter(logging.Formatter):
 
     # this is the default format to use for logging
-    log_format = "%(asctime)s %(levelname)s %(module)s:%(lineno)d - %(message)s"
+    log_format = (
+        "%(asctime)s %(levelname)s %(module)s:%(lineno)d - %(message)s")
 
     def __init__(self):
         super(LogFormatter, self).__init__(self.log_format)
@@ -124,8 +133,8 @@
 
 
 class Timer(object):
-
-    """A context-manager that times a block of code, writing the results to the log."""
+    """A context-manager that times a block of code, writing the results to
+    the log."""
 
     def __init__(self, code_name, log_level=logging.DEBUG):
         self.code_name = code_name
@@ -138,7 +147,9 @@
 
     def __exit__(self, *args):
         self.end = time.time()
-        self.logger.log(self.log_level, "'%s' took %.3fS", self.code_name, self.end - self.start)
+        self.logger.log(
+            self.log_level, "'%s' took %.3fS", self.code_name,
+            self.end - self.start)
 
 
 def get_debug_logger():
@@ -167,10 +178,15 @@
         @wraps(fn)
         def wrapped(*args, **kwargs):
             import sys
-            outerframe_details = inspect.getouterframes(inspect.currentframe())[1]
+            outerframe_details = inspect.getouterframes(
+                inspect.currentframe())[1]
             filename, line_number, function_name = outerframe_details[1:4]
-            sys.stderr.write("WARNING: in file \"{0}\", line {1} in {2}\n".format(filename, line_number, function_name))
-            sys.stderr.write("This function is deprecated. Please use '%s' instead.\n" % alternative)
+            sys.stderr.write(
+                "WARNING: in file \"{0}\", line {1} in {2}\n".format(
+                    filename, line_number, function_name))
+            sys.stderr.write(
+                "This function is deprecated. Please use '%s' instead.\n" %
+                alternative)
             return fn(*args, **kwargs)
         return wrapped
     return fdec
@@ -184,7 +200,9 @@
 
     def __call__(self, callable, *args, **kwargs):
         if self._test_instance is None:
-            raise RuntimeError("Out-of-test addCleanup can only be called while an autopilot test case is running!")
+            raise RuntimeError(
+                "Out-of-test addCleanup can only be called while an autopilot "
+                "test case is running!")
         self._test_instance.addCleanup(callable, *args, **kwargs)
 
     def set_test_instance(self, test_instance):
@@ -205,8 +223,8 @@
     """Metaclass to inject the object into on test start/end functionality"""
     def __new__(cls, classname, bases, classdict):
         class EmptyStaticMethod(object):
-            """Class used to give us 'default classmethods' for those that don't
-            provide them.
+            """Class used to give us 'default classmethods' for those that
+            don't provide them.
 
             """
             def __get__(self, obj, klass=None):
@@ -232,6 +250,7 @@
 
 
 class CleanupRegistered(object):
+
     __metaclass__ = _TestCleanupMeta