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

[Leo Arias]

Fixed pep8 errors in autopilot/functional.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Thomi Richards (thomir-deactivatedaccount)]

review: Approve

=== modified file 'autopilot/tests/functional/test_ap_apps.py'
--- autopilot/tests/functional/test_ap_apps.py	2013-05-29 11:23:51 +0000
+++ autopilot/tests/functional/test_ap_apps.py	2013-07-14 10:07:37 +0000
@@ -56,7 +56,8 @@
 introspection type to use. You can specify one by overriding the \
 AutopilotTestCase.pick_app_launcher method."
 
-        self.assertThat(lambda: self.launch_test_application(path),
+        self.assertThat(
+            lambda: self.launch_test_application(path),
             raises(RuntimeError(expected_error_message)))
 
 
@@ -64,9 +65,10 @@
 
     def _find_qt_binary_chooser(self, version, name):
         # Check for existence of the binary when qtchooser is installed
-        # We cannot use 'which', as qtchooser installs wrappers - we need to check
-        # in the actual library paths
-        env = subprocess.check_output(['qtchooser', '-qt=' + version, '-print-env']).split('\n')
+        # We cannot use 'which', as qtchooser installs wrappers - we need to
+        # check in the actual library paths
+        env = subprocess.check_output(
+            ['qtchooser', '-qt=' + version, '-print-env']).split('\n')
         for i in env:
             if i.find('QTTOOLDIR') >= 0:
                 path = i.lstrip("QTTOOLDIR=").strip('"') + "/" + name
@@ -78,21 +80,21 @@
     def _find_qt_binary_old(self, version, name):
         # Check for the existence of the binary the old way
         try:
-            path = subprocess.check_output(['which','qmlviewer']).strip()
+            path = subprocess.check_output(['which', 'qmlviewer']).strip()
         except subprocess.CalledProcessError:
             path = None
         return path
 
-
     def setUp(self):
         super(QtTests, self).setUp()
 
         try:
-            qtversions = subprocess.check_output(['qtchooser', '-list-versions']).split('\n')
+            qtversions = subprocess.check_output(
+                ['qtchooser', '-list-versions']).split('\n')
             check_func = self._find_qt_binary_chooser
         except OSError:
-            # This means no qtchooser is installed, so let's check for qmlviewer
-            # and qmlscene manually, the old way
+            # This means no qtchooser is installed, so let's check for
+            # qmlviewer and qmlscene manually, the old way
             qtversions = ['qt4', 'qt5']
             check_func = self._find_qt_binary_old
 
@@ -160,7 +162,8 @@
         super(GtkTests, self).setUp()
 
         try:
-            self.app_path = subprocess.check_output(['which','gnome-mahjongg']).strip()
+            self.app_path = subprocess.check_output(
+                ['which', 'gnome-mahjongg']).strip()
         except subprocess.CalledProcessError:
             self.skip("gnome-mahjongg not found.")
 

=== modified file 'autopilot/tests/functional/test_application_mixin.py'
--- autopilot/tests/functional/test_application_mixin.py	2013-05-16 06:12:58 +0000
+++ autopilot/tests/functional/test_application_mixin.py	2013-07-14 10:07:37 +0000
@@ -27,29 +27,42 @@
 class ApplicationSupportTests(AutopilotTestCase):
 
     def test_launch_with_bad_types_raises_typeerror(self):
-        """Calling launch_test_application with something other than a string must
-        raise a TypeError"""
+        """Calling launch_test_application with something other than a string
+        must raise a TypeError"""
 
-        self.assertThat(lambda: self.launch_test_application(1), raises(TypeError))
-        self.assertThat(lambda: self.launch_test_application(True), raises(TypeError))
-        self.assertThat(lambda: self.launch_test_application(1.0), raises(TypeError))
-        self.assertThat(lambda: self.launch_test_application(object()), raises(TypeError))
-        self.assertThat(lambda: self.launch_test_application(None), raises(TypeError))
-        self.assertThat(lambda: self.launch_test_application([]), raises(TypeError))
-        self.assertThat(lambda: self.launch_test_application((None,)), raises(TypeError))
+        self.assertThat(
+            lambda: self.launch_test_application(1), raises(TypeError))
+        self.assertThat(
+            lambda: self.launch_test_application(True), raises(TypeError))
+        self.assertThat(
+            lambda: self.launch_test_application(1.0), raises(TypeError))
+        self.assertThat(
+            lambda: self.launch_test_application(object()), raises(TypeError))
+        self.assertThat(
+            lambda: self.launch_test_application(None), raises(TypeError))
+        self.assertThat(
+            lambda: self.launch_test_application([]), raises(TypeError))
+        self.assertThat(
+            lambda: self.launch_test_application((None,)), raises(TypeError))
 
     def test_launch_raises_ValueError_on_unknown_kwargs(self):
         """launch_test_application must raise ValueError when given unknown
         keyword arguments.
 
         """
-        fn = lambda: self.launch_test_application('gedit', arg1=123, arg2='asd')
-        self.assertThat(fn, raises(ValueError("Unknown keyword arguments: 'arg1', 'arg2'.")))
+        fn = lambda: self.launch_test_application(
+            'gedit', arg1=123, arg2='asd')
+        self.assertThat(
+            fn,
+            raises(ValueError("Unknown keyword arguments: 'arg1', 'arg2'.")))
 
     def test_launch_raises_ValueError_on_unknown_kwargs_with_known(self):
         """launch_test_application must raise ValueError when given unknown
         keyword arguments.
 
         """
-        fn = lambda: self.launch_test_application('gedit', arg1=123, arg2='asd', launch_dir='/')
-        self.assertThat(fn, raises(ValueError("Unknown keyword arguments: 'arg1', 'arg2'.")))
+        fn = lambda: self.launch_test_application(
+            'gedit', arg1=123, arg2='asd', launch_dir='/')
+        self.assertThat(
+            fn,
+            raises(ValueError("Unknown keyword arguments: 'arg1', 'arg2'.")))

=== modified file 'autopilot/tests/functional/test_autopilot_functional.py'
--- autopilot/tests/functional/test_autopilot_functional.py	2013-07-09 11:29:06 +0000
+++ autopilot/tests/functional/test_autopilot_functional.py	2013-07-14 10:07:37 +0000
@@ -33,7 +33,6 @@
 from textwrap import dedent
 import re
 
-
 from autopilot.testcase import AutopilotTestCase
 
 
@@ -47,6 +46,7 @@
 
 logger = logging.getLogger(__name__)
 
+
 class AutopilotFunctionalTestsBase(AutopilotTestCase):
 
     """The base class for the autopilot functional tests."""
@@ -56,7 +56,8 @@
         self.base_path = self.create_empty_test_module()
 
     def create_empty_test_module(self):
-        """Create an empty temp directory, with an empty test directory inside it.
+        """Create an empty temp directory, with an empty test directory inside
+        it.
 
         This method handles cleaning up the directory once the test completes.
 
@@ -72,7 +73,7 @@
         # create the tests directory:
         os.mkdir(
             os.path.join(base_path, 'tests')
-            )
+        )
 
         # make tests importable:
         open(
@@ -90,8 +91,8 @@
                 '..',
                 '..',
                 '..'
-                )
             )
+        )
 
         environment_patch = dict(DISPLAY=':0')
         if not os.getcwd().startswith('/usr/'):
@@ -99,7 +100,8 @@
         bin_path = os.path.join(ap_base_path, 'bin', 'autopilot')
         if not os.path.exists(bin_path):
             bin_path = subprocess.check_output(['which', 'autopilot']).strip()
-            logger.info("Not running from source, setting bin_path to %s", bin_path)
+            logger.info(
+                "Not running from source, setting bin_path to %s", bin_path)
 
         environ = os.environ
         environ.update(environment_patch)
@@ -117,18 +119,20 @@
             env=environ,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
-            )
+        )
 
         stdout, stderr = process.communicate()
         retcode = process.poll()
 
         self.addDetail('retcode', text_content(str(retcode)))
-        self.addDetail('stdout', Content(
-            ContentType('text', 'plain', {'charset': 'iso-8859-1'}),
-            lambda:[stdout]))
-        self.addDetail('stderr', Content(
-            ContentType('text', 'plain', {'charset': 'iso-8859-1'}),
-            lambda:[stderr]))
+        self.addDetail(
+            'stdout', Content(
+                ContentType('text', 'plain', {'charset': 'iso-8859-1'}),
+            lambda: [stdout]))
+        self.addDetail(
+            'stderr', Content(
+                ContentType('text', 'plain', {'charset': 'iso-8859-1'}),
+            lambda: [stderr]))
 
         return (retcode, stdout, stderr)
 
@@ -155,8 +159,8 @@
     def run_autopilot_list(self, list_spec='tests', extra_args=[]):
         """Run 'autopilot list' in the specified base path.
 
-        This patches the environment to ensure that it's *this* version of autopilot
-        that's run.
+        This patches the environment to ensure that it's *this* version of
+        autopilot that's run.
 
         returns a tuple containing: (exit_code, stdout, stderr)
 
@@ -179,14 +183,15 @@
 
  %d total %s.
 ''' % (self.base_path,
-    ''.join(['    %s\n' % t for t in sorted(tests)]),
-    len(tests),
-    total_title)
+       ''.join(['    %s\n' % t for t in sorted(tests)]),
+       len(tests),
+       total_title)
 
         self.assertThat(output, Equals(expected))
 
     def test_can_list_empty_test_dir(self):
-        """Autopilot list must report 0 tests found with an empty test module."""
+        """Autopilot list must report 0 tests found with an empty test
+        module."""
         code, output, error = self.run_autopilot_list()
 
         self.assertThat(code, Equals(0))
@@ -195,7 +200,8 @@
 
     def test_can_list_tests(self):
         """Autopilot must find tests in a file."""
-        self.create_test_file('test_simple.py', dedent("""\
+        self.create_test_file(
+            'test_simple.py', dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -204,8 +210,8 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         # ideally these would be different tests, but I'm lazy:
         valid_test_specs = [
@@ -213,15 +219,17 @@
             'tests.test_simple',
             'tests.test_simple.SimpleTest',
             'tests.test_simple.SimpleTest.test_simple',
-            ]
+        ]
         for test_spec in valid_test_specs:
             code, output, error = self.run_autopilot_list(test_spec)
             self.assertThat(code, Equals(0))
             self.assertThat(error, Equals(''))
-            self.assertTestsInOutput(['tests.test_simple.SimpleTest.test_simple'], output)
+            self.assertTestsInOutput(
+                ['tests.test_simple.SimpleTest.test_simple'], output)
 
     def test_list_tests_with_import_error(self):
-        self.create_test_file('test_simple.py', dedent("""\
+        self.create_test_file(
+            'test_simple.py', dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             # create an import error:
@@ -231,8 +239,8 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
         code, output, error = self.run_autopilot_list()
         expected_regex = '''\
 Loading tests from: %s
@@ -241,7 +249,8 @@
 Traceback \(most recent call last\):
   File "/usr/lib/python2.7/unittest/loader.py", line 252, in _find_tests
     module = self._get_module_from_name\(name\)
-  File "/usr/lib/python2.7/unittest/loader.py", line 230, in _get_module_from_name
+  File "/usr/lib/python2.7/unittest/loader.py", line 230, in \
+_get_module_from_name
     __import__\(name\)
   File "/tmp/\w*/tests/test_simple.py", line 4, in <module>
     import asdjkhdfjgsdhfjhsd
@@ -253,7 +262,8 @@
         self.assertTrue(re.search(expected_regex, output, re.MULTILINE))
 
     def test_list_tests_with_syntax_error(self):
-        self.create_test_file('test_simple.py', dedent("""\
+        self.create_test_file(
+            'test_simple.py', dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             # create a syntax error:
@@ -263,8 +273,8 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
         code, output, error = self.run_autopilot_list()
         expected_regex = '''\
 Loading tests from: %s
@@ -273,7 +283,8 @@
 Traceback \(most recent call last\):
   File "/usr/lib/python2.7/unittest/loader.py", line 252, in _find_tests
     module = self._get_module_from_name\(name\)
-  File "/usr/lib/python2.7/unittest/loader.py", line 230, in _get_module_from_name
+  File "/usr/lib/python2.7/unittest/loader.py", line 230, in \
+_get_module_from_name
     __import__\(name\)
   File "/tmp/\w*/tests/test_simple.py", line 4
     \.\.
@@ -286,8 +297,10 @@
         self.assertTrue(re.search(expected_regex, output, re.MULTILINE))
 
     def test_can_list_scenariod_tests(self):
-        """Autopilot must show scenario counts next to tests that have scenarios."""
-        self.create_test_file('test_simple.py', dedent("""\
+        """Autopilot must show scenario counts next to tests that have
+        scenarios."""
+        self.create_test_file(
+            'test_simple.py', dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -300,8 +313,8 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         expected_output = '''\
 Loading tests from: %s
@@ -318,12 +331,15 @@
         self.assertThat(output, Equals(expected_output))
 
     def test_can_list_scenariod_tests_with_multiple_scenarios(self):
-        """Autopilot must show scenario counts next to tests that have scenarios.
+        """Autopilot must show scenario counts next to tests that have
+        scenarios.
 
-        Tests multiple scenarios on a single test suite with multiple test cases.
+        Tests multiple scenarios on a single test suite with multiple test
+        cases.
 
         """
-        self.create_test_file('test_simple.py', dedent("""\
+        self.create_test_file(
+            'test_simple.py', dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -340,8 +356,8 @@
 
                 def test_simple_two(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         expected_output = '''\
 Loading tests from: %s
@@ -360,7 +376,8 @@
 
     def test_can_list_invalid_scenarios(self):
         """Autopilot must ignore scenarios that are not lists."""
-        self.create_test_file('test_simple.py', dedent("""\
+        self.create_test_file(
+            'test_simple.py', dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -371,17 +388,19 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot_list()
         self.assertThat(code, Equals(0))
         self.assertThat(error, Equals(''))
-        self.assertTestsInOutput(['tests.test_simple.SimpleTest.test_simple'], output)
+        self.assertTestsInOutput(
+            ['tests.test_simple.SimpleTest.test_simple'], output)
 
     def test_can_list_just_suites(self):
         """Must only list available suites, not the contained tests."""
-        self.create_test_file('test_simple_suites.py', dedent("""\
+        self.create_test_file(
+            'test_simple_suites.py', dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -398,23 +417,25 @@
 
                 def test_yet_another_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot_list(extra_args=['--suites'])
         self.assertThat(code, Equals(0))
         self.assertThat(error, Equals(''))
-        self.assertTestsInOutput(['tests.test_simple_suites.SimpleTest',
-                                  'tests.test_simple_suites.AnotherSimpleTest'],
-                                 output,
-                                 total_title='suites')
+        self.assertTestsInOutput(
+            ['tests.test_simple_suites.SimpleTest',
+             'tests.test_simple_suites.AnotherSimpleTest'],
+            output, total_title='suites')
 
     def test_record_flag_works(self):
         """Must be able to record videos when the -r flag is present."""
 
-        # The sleep is to avoid the case where recordmydesktop does not create a
-        # file because it gets stopped before it's even started capturing anything.
-        self.create_test_file("test_simple.py", dedent("""\
+        # The sleep is to avoid the case where recordmydesktop does not create
+        # a file because it gets stopped before it's even started capturing
+        # anything.
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             from time import sleep
@@ -424,30 +445,34 @@
                 def test_simple(self):
                     sleep(1)
                     self.fail()
-            """
-            ))
+            """)
+        )
 
         should_delete = not os.path.exists('/tmp/autopilot')
         if should_delete:
             self.addCleanup(remove_if_exists, "/tmp/autopilot")
         else:
-            self.addCleanup(remove_if_exists,
-                            '/tmp/autopilot/tests.test_simple.SimpleTest.test_simple.ogv')
+            self.addCleanup(
+                remove_if_exists,
+                '/tmp/autopilot/tests.test_simple.SimpleTest.test_simple.ogv')
 
         code, output, error = self.run_autopilot(["run", "-r", "tests"])
 
         self.assertThat(code, Equals(1))
         self.assertTrue(os.path.exists('/tmp/autopilot'))
-        self.assertTrue(os.path.exists('/tmp/autopilot/tests.test_simple.SimpleTest.test_simple.ogv'))
+        self.assertTrue(os.path.exists(
+            '/tmp/autopilot/tests.test_simple.SimpleTest.test_simple.ogv'))
         if should_delete:
             self.addCleanup(remove_if_exists, "/tmp/autopilot")
 
     def test_record_dir_option_and_record_works(self):
         """Must be able to specify record directory flag and record."""
 
-        # The sleep is to avoid the case where recordmydesktop does not create a
-        # file because it gets stopped before it's even started capturing anything.
-        self.create_test_file("test_simple.py", dedent("""\
+        # The sleep is to avoid the case where recordmydesktop does not create
+        # a file because it gets stopped before it's even started capturing
+        # anything.
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             from time import sleep
@@ -458,8 +483,8 @@
                 def test_simple(self):
                     sleep(1)
                     self.fail()
-            """
-            ))
+            """)
+        )
         video_dir = mktemp()
         ap_dir = '/tmp/autopilot'
         self.addCleanup(remove_if_exists, video_dir)
@@ -468,22 +493,29 @@
         if should_delete:
             self.addCleanup(remove_if_exists, ap_dir)
         else:
-            self.addCleanup(remove_if_exists,
-                            '%s/tests.test_simple.SimpleTest.test_simple.ogv' % (ap_dir))
+            self.addCleanup(
+                remove_if_exists,
+                '%s/tests.test_simple.SimpleTest.test_simple.ogv' % (ap_dir))
 
-        code, output, error = self.run_autopilot(["run", "-r", "-rd", video_dir, "tests"])
+        code, output, error = self.run_autopilot(
+            ["run", "-r", "-rd", video_dir, "tests"])
 
         self.assertThat(code, Equals(1))
         self.assertTrue(os.path.exists(video_dir))
-        self.assertTrue(os.path.exists('%s/tests.test_simple.SimpleTest.test_simple.ogv' % (video_dir)))
-        self.assertFalse(os.path.exists('%s/tests.test_simple.SimpleTest.test_simple.ogv' % (ap_dir)))
+        self.assertTrue(os.path.exists(
+            '%s/tests.test_simple.SimpleTest.test_simple.ogv' % (video_dir)))
+        self.assertFalse(
+            os.path.exists(
+                '%s/tests.test_simple.SimpleTest.test_simple.ogv' % (ap_dir)))
 
     def test_record_dir_option_works(self):
         """Must be able to specify record directory flag."""
 
-        # The sleep is to avoid the case where recordmydesktop does not create a
-        # file because it gets stopped before it's even started capturing anything.
-        self.create_test_file("test_simple.py", dedent("""\
+        # The sleep is to avoid the case where recordmydesktop does not create
+        # a file because it gets stopped before it's even started capturing
+        # anything.
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             from time import sleep
@@ -494,20 +526,25 @@
                 def test_simple(self):
                     sleep(1)
                     self.fail()
-            """
-            ))
+            """)
+        )
         video_dir = mktemp()
         self.addCleanup(remove_if_exists, video_dir)
 
-        code, output, error = self.run_autopilot(["run", "-rd", video_dir, "tests"])
+        code, output, error = self.run_autopilot(
+            ["run", "-rd", video_dir, "tests"])
 
         self.assertThat(code, Equals(1))
         self.assertTrue(os.path.exists(video_dir))
-        self.assertTrue(os.path.exists('%s/tests.test_simple.SimpleTest.test_simple.ogv' % (video_dir)))
+        self.assertTrue(
+            os.path.exists(
+                '%s/tests.test_simple.SimpleTest.test_simple.ogv' %
+                (video_dir)))
 
     def test_no_videos_saved_when_record_option_is_not_present(self):
         """Videos must not be saved if the '-r' option is not specified."""
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             from time import sleep
@@ -517,9 +554,10 @@
                 def test_simple(self):
                     sleep(1)
                     self.fail()
-            """
-            ))
-        self.addCleanup(remove_if_exists,
+            """)
+        )
+        self.addCleanup(
+            remove_if_exists,
             '/tmp/autopilot/tests.test_simple.SimpleTest.test_simple.ogv')
 
         code, output, error = self.run_autopilot(["run", "tests"])
@@ -533,7 +571,8 @@
         failed).
 
         """
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             from time import sleep
@@ -543,10 +582,11 @@
                 def test_simple(self):
                     sleep(1)
                     self.skip("Skipping Test")
-            """
-            ))
+            """)
+        )
 
-        video_file_path = '/tmp/autopilot/tests.test_simple.SimpleTest.test_simple.ogv'
+        video_file_path = (
+            '/tmp/autopilot/tests.test_simple.SimpleTest.test_simple.ogv')
         self.addCleanup(remove_if_exists, video_file_path)
 
         code, output, error = self.run_autopilot(["run", "-r", "tests"])
@@ -554,12 +594,13 @@
         self.assertThat(code, Equals(0))
         self.assertThat(os.path.exists(video_file_path), Equals(False))
 
-    def test_no_video_file_for_nested_testcase_when_parent_and_child_testcase_fail(self):
+    def test_no_video_for_nested_testcase_when_parent_and_child_fail(self):
         """Test recording must not create a new recording for nested testcases
         where both the parent and the child testcase fail.
 
         """
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             import os
@@ -574,11 +615,15 @@
 
                     InnerTestCase("test_will_fail").run()
                     self.assertTrue(False)
-            """
-            ))
+            """)
+        )
 
-        expected_video_file = '/tmp/autopilot/tests.test_simple.OuterTestCase.test_nested_classes.ogv'
-        erroneous_video_file = '/tmp/autopilot/tests.test_simple.OuterTestCase.test_nested_classes.InnerTestCase.test_will_fail.ogv'
+        expected_video_file = (
+            '/tmp/autopilot/tests.test_simple.OuterTestCase.'
+            'test_nested_classes.ogv')
+        erroneous_video_file = (
+            '/tmp/autopilot/tests.test_simple.OuterTestCase.'
+            'test_nested_classes.InnerTestCase.test_will_fail.ogv')
 
         self.addCleanup(remove_if_exists, expected_video_file)
         self.addCleanup(remove_if_exists, erroneous_video_file)
@@ -591,7 +636,8 @@
 
     def test_runs_with_import_errors_fail(self):
         """Import errors inside a test must be considered a test failure."""
-        self.create_test_file('test_simple.py', dedent("""\
+        self.create_test_file(
+            'test_simple.py', dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             # create an import error:
@@ -601,8 +647,8 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run", "tests"])
 
@@ -613,7 +659,8 @@
 Traceback \(most recent call last\):
   File "/usr/lib/python2.7/unittest/loader.py", line 252, in _find_tests
     module = self._get_module_from_name\(name\)
-  File "/usr/lib/python2.7/unittest/loader.py", line 230, in _get_module_from_name
+  File "/usr/lib/python2.7/unittest/loader.py", line 230, in \
+_get_module_from_name
     __import__\(name\)
   File "/tmp/\w*/tests/test_simple.py", line 4, in <module>
     import asdjkhdfjgsdhfjhsd
@@ -628,7 +675,8 @@
 
     def test_runs_with_syntax_errors_fail(self):
         """Import errors inside a test must be considered a test failure."""
-        self.create_test_file('test_simple.py', dedent("""\
+        self.create_test_file(
+            'test_simple.py', dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             # create a syntax error:
@@ -638,8 +686,8 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run", "tests"])
 
@@ -650,7 +698,8 @@
 Traceback \(most recent call last\):
   File "/usr/lib/python2.7/unittest/loader.py", line 252, in _find_tests
     module = self._get_module_from_name\(name\)
-  File "/usr/lib/python2.7/unittest/loader.py", line 230, in _get_module_from_name
+  File "/usr/lib/python2.7/unittest/loader.py", line 230, in \
+_get_module_from_name
     __import__\(name\)
   File "/tmp/\w*/tests/test_simple.py", line 4
     \.\.
@@ -665,8 +714,10 @@
         self.assertThat(output, Contains("FAILED (failures=1)"))
 
     def test_can_error_with_unicode_data(self):
-        """Tests that assert with unicode errors must get saved to a log file."""
-        self.create_test_file("test_simple.py", dedent(u"""\
+        """Tests that assert with unicode errors must get saved to a log
+        file."""
+        self.create_test_file(
+            "test_simple.py", dedent(u"""\
             # encoding: utf-8
 
             # from autopilot.testcase import AutopilotTestCase
@@ -675,24 +726,30 @@
             class SimpleTest(TestCase):
 
                 def test_simple(self):
-                    self.fail(u'\xa1pl\u0279oM \u01ddpo\u0254\u0131u\u2229 oll\u01ddH')
+                    self.fail(
+                        u'\xa1pl\u0279oM \u01ddpo\u0254\u0131u\u2229 oll'
+                        u'\u01ddH')
 
-            """
-            ))
+            """)
+        )
         output_file_path = mktemp()
         self.addCleanup(remove_if_exists, output_file_path)
 
-        code, output, error = self.run_autopilot(["run", "-o", output_file_path, "tests"])
+        code, output, error = self.run_autopilot(
+            ["run", "-o", output_file_path, "tests"])
 
         self.assertThat(code, Equals(1))
         self.assertTrue(os.path.exists(output_file_path))
         log_contents = unicode(open(output_file_path, encoding='utf-8').read())
-        self.assertThat(log_contents,
+        self.assertThat(
+            log_contents,
             Contains(u'\xa1pl\u0279oM \u01ddpo\u0254\u0131u\u2229 oll\u01ddH'))
 
     def test_can_write_xml_error_with_unicode_data(self):
-        """Tests that assert with unicode errors must get saved to XML log file."""
-        self.create_test_file("test_simple.py", dedent(u"""\
+        """Tests that assert with unicode errors must get saved to XML log
+        file."""
+        self.create_test_file(
+            "test_simple.py", dedent(u"""\
             # encoding: utf-8
 
             # from autopilot.testcase import AutopilotTestCase
@@ -701,10 +758,12 @@
             class SimpleTest(TestCase):
 
                 def test_simple(self):
-                    self.fail(u'\xa1pl\u0279oM \u01ddpo\u0254\u0131u\u2229 oll\u01ddH')
+                    error = (u'\xa1pl\u0279oM \u01ddpo\u0254\u0131u'
+                        u'\u2229 oll\u01ddH')
+                    self.fail(error)
 
-            """
-            ))
+            """)
+        )
         output_file_path = mktemp()
         self.addCleanup(remove_if_exists, output_file_path)
 
@@ -717,45 +776,58 @@
         self.assertThat(code, Equals(1))
         self.assertTrue(os.path.exists(output_file_path))
         log_contents = unicode(open(output_file_path, encoding='utf-8').read())
-        self.assertThat(log_contents,
+        self.assertThat(
+            log_contents,
             Contains(u'\xa1pl\u0279oM \u01ddpo\u0254\u0131u\u2229 oll\u01ddH'))
 
     def test_launch_needs_arguments(self):
-        """Autopilot launch must complain if not given an application to launch."""
+        """Autopilot launch must complain if not given an application to
+        launch."""
         rc, _, _ = self.run_autopilot(["launch"])
         self.assertThat(rc, Equals(2))
 
     def test_complains_on_unknown_introspection_type(self):
-        """Launching a binary that does not support an introspection type we are
-        familiar with must result in a nice error message.
+        """Launching a binary that does not support an introspection type we
+        are familiar with must result in a nice error message.
 
         """
         rc, stdout, _ = self.run_autopilot(["launch", "yes"])
 
         self.assertThat(rc, Equals(1))
-        self.assertThat(stdout,
-            Contains("Error: Could not determine introspection type to use for application '/usr/bin/yes'"))
+        self.assertThat(
+            stdout,
+            Contains(
+                "Error: Could not determine introspection type to use for "
+                "application '/usr/bin/yes'"))
 
     def test_complains_on_missing_file(self):
-        """Must give a nice error message if we try and launch a binary that's missing."""
+        """Must give a nice error message if we try and launch a binary that's
+        missing."""
         rc, stdout, _ = self.run_autopilot(["launch", "DoEsNotExist"])
 
         self.assertThat(rc, Equals(1))
-        self.assertThat(stdout,
-            Contains("Error: cannot find application 'DoEsNotExist'"))
+        self.assertThat(
+            stdout, Contains("Error: cannot find application 'DoEsNotExist'"))
 
     def test_complains_on_non_dynamic_binary(self):
-        """Must give a nice error message when passing in a non-dynamic binary."""
-        #tzselect is a bash script, and is in the base system, so should always exist.
+        """Must give a nice error message when passing in a non-dynamic
+        binary."""
+        # tzselect is a bash script, and is in the base system, so should
+        # always exist.
         rc, stdout, _ = self.run_autopilot(["launch", "tzselect"])
 
         self.assertThat(rc, Equals(1))
-        self.assertThat(stdout,
-            Contains("Error detecting launcher: Command '['ldd', '/usr/bin/tzselect']' returned non-zero exit status 1\n(Perhaps use the '-i' argument to specify an interface.)\n"))
+        self.assertThat(
+            stdout, Contains(
+                "Error detecting launcher: Command '['ldd', "
+                "'/usr/bin/tzselect']' returned non-zero exit status 1\n"
+                "(Perhaps use the '-i' argument to specify an interface.)\n")
+        )
 
     def test_run_random_order_flag_works(self):
         """Must run tests in random order when -ro is used"""
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             from time import sleep
@@ -766,9 +838,8 @@
                     pass
                 def test_simple_two(self):
                     pass
-            """
-            ))
-
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run", "-ro", "tests"])
 
@@ -777,7 +848,8 @@
 
     def test_run_random_flag_not_used(self):
         """Must not run tests in random order when -ro is not used"""
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             from time import sleep
@@ -788,9 +860,8 @@
                     pass
                 def test_simple_two(self):
                     pass
-            """
-            ))
-
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run", "tests"])
 
@@ -798,7 +869,6 @@
         self.assertThat(output, Not(Contains('Running tests in random order')))
 
 
-
 class AutopilotVerboseFunctionalTests(AutopilotFunctionalTestsBase):
 
     """Scenarioed functional tests for autopilot's verbose logging."""
@@ -810,7 +880,8 @@
 
     def test_verbose_flag_works(self):
         """Verbose flag must log to stderr."""
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -819,19 +890,22 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run",
                                                   "-f", self.output_format,
                                                   "-v", "tests"])
 
         self.assertThat(code, Equals(0))
-        self.assertThat(error, Contains("Starting test tests.test_simple.SimpleTest.test_simple"))
+        self.assertThat(
+            error, Contains(
+                "Starting test tests.test_simple.SimpleTest.test_simple"))
 
     def test_verbose_flag_shows_timestamps(self):
         """Verbose log must include timestamps."""
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -840,8 +914,8 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run",
                                                   "-f", self.output_format,
@@ -851,7 +925,8 @@
 
     def test_verbose_flag_shows_success(self):
         """Verbose log must indicate successful tests (text format)."""
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -860,18 +935,20 @@
 
                 def test_simple(self):
                     pass
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run",
                                                   "-f", self.output_format,
                                                   "-v", "tests"])
 
-        self.assertThat(error, Contains("OK: tests.test_simple.SimpleTest.test_simple"))
+        self.assertThat(
+            error, Contains("OK: tests.test_simple.SimpleTest.test_simple"))
 
     def test_verbose_flag_shows_error(self):
         """Verbose log must indicate test error with a traceback."""
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -880,20 +957,25 @@
 
                 def test_simple(self):
                     self.assertTrue()
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run",
                                                   "-f", self.output_format,
                                                   "-v", "tests"])
 
-        self.assertThat(error, Contains("ERROR: tests.test_simple.SimpleTest.test_simple"))
+        self.assertThat(
+            error, Contains("ERROR: tests.test_simple.SimpleTest.test_simple"))
         self.assertThat(error, Contains("traceback:"))
-        self.assertThat(error, Contains("TypeError: assertTrue() takes at least 2 arguments (1 given)"))
+        self.assertThat(
+            error, Contains("TypeError: assertTrue() takes at least 2 "
+                            "arguments (1 given)"))
 
     def test_verbose_flag_shows_failure(self):
-        """Verbose log must indicate a test failure with a traceback (xml format)."""
-        self.create_test_file("test_simple.py", dedent("""\
+        """Verbose log must indicate a test failure with a traceback (xml
+        format)."""
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
 
@@ -902,8 +984,8 @@
 
                 def test_simple(self):
                     self.assertTrue(False)
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run",
                                                   "-f", self.output_format,
@@ -914,8 +996,10 @@
         self.assertIn("AssertionError: False is not true", error)
 
     def test_verbose_flag_captures_nested_autopilottestcase_classes(self):
-        """Verbose log must contain the log details of both the nested and parent testcase."""
-        self.create_test_file("test_simple.py", dedent("""\
+        """Verbose log must contain the log details of both the nested and
+        parent testcase."""
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             import os
@@ -930,20 +1014,27 @@
 
                     InnerTestCase("test_produce_log_output").run()
                     self.assertTrue(True)
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run",
                                                   "-f", self.output_format,
                                                   "-v", "tests"])
 
         self.assertThat(code, Equals(0))
-        self.assertThat(error, Contains("Starting test tests.test_simple.OuterTestCase.test_nested_classes"))
-        self.assertThat(error, Contains("Starting test tests.test_simple.InnerTestCase.test_produce_log_output"))
+        self.assertThat(
+            error, Contains(
+                "Starting test tests.test_simple.OuterTestCase."
+                "test_nested_classes"))
+        self.assertThat(
+            error, Contains(
+                "Starting test tests.test_simple.InnerTestCase."
+                "test_produce_log_output"))
 
     def test_can_enable_debug_output(self):
         """Verbose log must show debug messages if we specify '-vv'."""
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             from autopilot.utilities import get_debug_logger
@@ -953,8 +1044,8 @@
 
                 def test_simple(self):
                     get_debug_logger().debug("Hello World")
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run",
                                                   "-f", self.output_format,
@@ -964,7 +1055,8 @@
 
     def test_debug_output_not_shown_by_default(self):
         """Verbose log must not show debug messages unless we specify '-vv'."""
-        self.create_test_file("test_simple.py", dedent("""\
+        self.create_test_file(
+            "test_simple.py", dedent("""\
 
             from autopilot.testcase import AutopilotTestCase
             from autopilot.utilities import get_debug_logger
@@ -974,8 +1066,8 @@
 
                 def test_simple(self):
                     get_debug_logger().debug("Hello World")
-            """
-            ))
+            """)
+        )
 
         code, output, error = self.run_autopilot(["run",
                                                   "-f", self.output_format,

=== modified file 'autopilot/tests/functional/test_custom_assertions.py'
--- autopilot/tests/functional/test_custom_assertions.py	2013-05-16 06:12:58 +0000
+++ autopilot/tests/functional/test_custom_assertions.py	2013-07-14 10:07:37 +0000
@@ -44,9 +44,11 @@
     test_object = TestObject()
 
     def test_assertProperty_raises_valueerror_on_empty_test(self):
-        """assertProperty must raise ValueError if called without any kwargs."""
+        """assertProperty must raise ValueError if called without any
+        kwargs."""
 
-        self.assertThat(lambda: self.assertProperty(self.test_object), raises(ValueError))
+        self.assertThat(
+            lambda: self.assertProperty(self.test_object), raises(ValueError))
 
     def test_assertProperty_raises_valueerror_on_callable(self):
         """assertProperty must raise ValueError when called with a callable
@@ -54,15 +56,17 @@
 
         """
 
-        self.assertThat(lambda: self.assertProperty(self.test_object, test_method=456),
+        self.assertThat(
+            lambda: self.assertProperty(self.test_object, test_method=456),
             raises(ValueError))
 
     def test_assertProperty_raises_assert_with_single_property(self):
-        """assertProperty must raise an AssertionError when called with a single
-        property.
+        """assertProperty must raise an AssertionError when called with a
+        single property.
 
         """
-        self.assertThat(lambda: self.assertProperty(self.test_object, test_property=234),
+        self.assertThat(
+            lambda: self.assertProperty(self.test_object, test_property=234),
             raises(AssertionError))
 
     def test_assertProperty_doesnt_raise(self):
@@ -71,7 +75,8 @@
 
         """
 
-        self.assertThat(lambda: self.assertProperty(self.test_object, test_property=123),
+        self.assertThat(
+            lambda: self.assertProperty(self.test_object, test_property=123),
             Not(raises(AssertionError)))
 
     def test_assertProperty_doesnt_raise_multiples(self):
@@ -80,29 +85,41 @@
 
         """
 
-        self.assertThat(lambda: self.assertProperty(self.test_object, test_property=123, another_property="foobar"),
+        self.assertThat(
+            lambda: self.assertProperty(
+                self.test_object, test_property=123,
+                another_property="foobar"),
             Not(raises(AssertionError)))
 
     def test_assertProperty_raises_assert_with_double_properties(self):
-        """assertProperty must raise an AssertionError when called with multiple
-        properties.
+        """assertProperty must raise an AssertionError when called with
+        multiple properties.
 
         """
-        self.assertThat(lambda: self.assertProperty(self.test_object, test_property=234, another_property=123),
+        self.assertThat(
+            lambda: self.assertProperty(
+                self.test_object, test_property=234, another_property=123),
             raises(AssertionError))
 
     def test_assertProperties_works(self):
-        """Asserts that the assertProperties method is a synonym for assertProperty."""
+        """Asserts that the assertProperties method is a synonym for
+        assertProperty."""
         self.assertThat(callable(self.assertProperties), Equals(True))
-        self.assertThat(lambda: self.assertProperties(self.test_object, test_property=123, another_property="foobar"),
+        self.assertThat(
+            lambda: self.assertProperties(
+                self.test_object, test_property=123,
+                another_property="foobar"),
             Not(raises(AssertionError)))
 
     def test_assertProperty_raises_assertionerror_on_no_such_property(self):
-        """AssertProperty must rise an AssertionError if the property is not found."""
-        self.assertThat(lambda: self.assertProperty(self.test_object, foo="bar"),
+        """AssertProperty must rise an AssertionError if the property is not
+        found."""
+        self.assertThat(
+            lambda: self.assertProperty(self.test_object, foo="bar"),
             raises(AssertionError))
 
     def test_assertProperty_works_for_None_properties(self):
         """Must be able to match properties whose values are None."""
-        self.assertThat(lambda: self.assertProperties(self.test_object, none_prop=None),
+        self.assertThat(
+            lambda: self.assertProperties(self.test_object, none_prop=None),
             Not(raises(AssertionError)))

=== modified file 'autopilot/tests/functional/test_dbus_query.py'
--- autopilot/tests/functional/test_dbus_query.py	2013-05-05 02:39:14 +0000
+++ autopilot/tests/functional/test_dbus_query.py	2013-07-14 10:07:37 +0000
@@ -62,7 +62,8 @@
         json.dump(window_spec, open(file_path, 'w'))
         self.addCleanup(os.remove, file_path)
 
-        return self.launch_test_application('window-mocker', file_path, app_type="qt")
+        return self.launch_test_application(
+            'window-mocker', file_path, app_type="qt")
 
     def test_select_single_selects_only_available_object(self):
         """Must be able to select a single unique object."""

=== modified file 'autopilot/tests/functional/test_input_stack.py'
--- autopilot/tests/functional/test_input_stack.py	2013-07-05 04:02:23 +0000
+++ autopilot/tests/functional/test_input_stack.py	2013-07-14 10:07:37 +0000
@@ -191,10 +191,12 @@
 
         self.assertThat(FakeKeyboard.cleanup_called, Equals(True))
 
+
 class InputStackCleanup(AutopilotTestCase):
 
     def test_keyboard_keys_released_X11(self):
-        """Cleanup must release any keys that an X11 keyboard has had pressed."""
+        """Cleanup must release any keys that an X11 keyboard has had
+        pressed."""
         class FakeTestCase(AutopilotTestCase):
             def test_press_key(self):
                 kb = Keyboard.create('X11')
@@ -207,7 +209,8 @@
         self.assertThat(_PRESSED_KEYS, Equals([]))
 
     def test_keyboard_keys_released_UInput(self):
-        """Cleanup must release any keys that an UInput keyboard has had pressed."""
+        """Cleanup must release any keys that an UInput keyboard has had
+        pressed."""
         class FakeTestCase(AutopilotTestCase):
             def test_press_key(self):
                 kb = Keyboard.create('UInput')

=== modified file 'autopilot/tests/functional/test_introspection_features.py'
--- autopilot/tests/functional/test_introspection_features.py	2013-07-10 01:07:57 +0000
+++ autopilot/tests/functional/test_introspection_features.py	2013-07-14 10:07:37 +0000
@@ -39,11 +39,11 @@
 
     def start_mock_app(self, emulator_base):
         window_spec_file = mktemp(suffix='.json')
-        window_spec = { "Contents": "MouseTest" }
+        window_spec = {"Contents": "MouseTest"}
         json.dump(
             window_spec,
             open(window_spec_file, 'w')
-            )
+        )
         self.addCleanup(os.remove, window_spec_file)
 
         return self.launch_test_application(
@@ -51,7 +51,7 @@
             window_spec_file,
             app_type='qt',
             emulator_base=emulator_base,
-            )
+        )
 
     def test_can_select_custom_emulators_by_name(self):
         """Must be able to select a custom emulator type by name."""
@@ -122,4 +122,3 @@
         self.assertThat(result1.wasSuccessful(), Equals(True))
         result2 = InnerTestCase('test_custom_emulator').run()
         self.assertThat(result2.wasSuccessful(), Equals(True))
-

=== modified file 'autopilot/tests/functional/test_mouse_emulator.py'
--- autopilot/tests/functional/test_mouse_emulator.py	2013-06-05 17:03:20 +0000
+++ autopilot/tests/functional/test_mouse_emulator.py	2013-07-14 10:07:37 +0000
@@ -24,20 +24,23 @@
 
 from autopilot.input import Pointer, Mouse
 
+
 class Empty(object):
     pass
 
+
 def make_fake_object(globalRect=False, center=False, xywh=False):
     obj = Empty()
     if globalRect:
-        obj.globalRect = (0,0,100,100)
+        obj.globalRect = (0, 0, 100, 100)
     if center:
         obj.center_x = 123
         obj.center_y = 345
     if xywh:
-        obj.x, obj.y, obj.w, obj.h = (100,100,20,40)
+        obj.x, obj.y, obj.w, obj.h = (100, 100, 20, 40)
     return obj
 
+
 class MouseEmulatorTests(TestCase):
     """Tests for the autopilot mouse emulator."""
 
@@ -50,8 +53,10 @@
         self.mouse = None
 
     def test_x_y_properties(self):
-        """x and y properties must simply return values from the position() method."""
-        with patch.object(self.mouse._device, 'position', return_value=(42,37)):
+        """x and y properties must simply return values from the position()
+        method."""
+        with patch.object(
+                self.mouse._device, 'position', return_value=(42, 37)):
             self.assertThat(self.mouse.x, Equals(42))
             self.assertThat(self.mouse.y, Equals(37))
 
@@ -59,40 +64,45 @@
         """Passing an empty object to move_to_object must raise ValueError."""
         obj = make_fake_object()
         fn = lambda: self.mouse.move_to_object(obj)
-        expected_exception = ValueError("Object '%r' does not have any recognised position attributes" % obj)
+        expected_exception = ValueError(
+            "Object '%r' does not have any recognised position attributes" %
+            obj)
         self.assertThat(fn, raises(expected_exception))
 
     def test_move_to_object_works_with_globalRect_only(self):
-        """move_to_object must move to the coordinates set in globalRect attribute."""
+        """move_to_object must move to the coordinates set in globalRect
+        attribute."""
         obj = make_fake_object(globalRect=True)
         with patch.object(self.mouse, 'move') as move_patch:
             self.mouse.move_to_object(obj)
-            move_patch.assert_called_once_with(50,50)
+            move_patch.assert_called_once_with(50, 50)
 
     def test_move_to_object_works_with_center_only(self):
-        """move_to_object must move to the coordinates set in the center_x, center_y attributes."""
+        """move_to_object must move to the coordinates set in the center_x,
+        center_y attributes."""
         obj = make_fake_object(center=True)
         with patch.object(self.mouse, 'move') as move_patch:
             self.mouse.move_to_object(obj)
-            move_patch.assert_called_once_with(123,345)
+            move_patch.assert_called_once_with(123, 345)
 
     def test_move_to_object_works_with_x_y_w_h_only(self):
-        """move_to_object must move to the coordinates set in the x, y, w & h attributes."""
+        """move_to_object must move to the coordinates set in the x, y, w & h
+        attributes."""
         obj = make_fake_object(xywh=True)
         with patch.object(self.mouse, 'move') as move_patch:
             self.mouse.move_to_object(obj)
-            move_patch.assert_called_once_with(110,120)
+            move_patch.assert_called_once_with(110, 120)
 
     def test_move_to_object_prefers_globalRect(self):
         """move_to_object must prefer globalRect over the other attributes."""
         obj = make_fake_object(globalRect=True, center=True, xywh=True)
         with patch.object(self.mouse, 'move') as move_patch:
             self.mouse.move_to_object(obj)
-            move_patch.assert_called_once_with(50,50)
+            move_patch.assert_called_once_with(50, 50)
 
     def test_move_to_object_prefers_center(self):
         """move_to_object must prefer center_[xy] to the xywh attributes."""
         obj = make_fake_object(globalRect=False, center=True, xywh=True)
         with patch.object(self.mouse, 'move') as move_patch:
             self.mouse.move_to_object(obj)
-            move_patch.assert_called_once_with(123,345)
+            move_patch.assert_called_once_with(123, 345)

=== modified file 'autopilot/tests/functional/test_open_window.py'
--- autopilot/tests/functional/test_open_window.py	2013-05-05 02:39:14 +0000
+++ autopilot/tests/functional/test_open_window.py	2013-07-14 10:07:37 +0000
@@ -30,7 +30,8 @@
 
 class OpenWindowTests(AutopilotTestCase):
 
-    scenarios = [(k, {'app_name': k}) for k in ProcessManager.KNOWN_APPS.iterkeys()]
+    scenarios = [
+        (k, {'app_name': k}) for k in ProcessManager.KNOWN_APPS.iterkeys()]
 
     def test_open_window(self):
         """self.start_app_window must open a new window of the given app."""

=== modified file 'autopilot/tests/functional/test_process_emulator.py'
--- autopilot/tests/functional/test_process_emulator.py	2013-07-10 02:02:33 +0000
+++ autopilot/tests/functional/test_process_emulator.py	2013-07-14 10:07:37 +0000
@@ -34,9 +34,11 @@
 
     def ensure_gedit_not_running(self):
         """Close any open gedit applications."""
-        apps = self.process_manager.get_running_applications_by_desktop_file('gedit.desktop')
+        apps = self.process_manager.get_running_applications_by_desktop_file(
+            'gedit.desktop')
         if apps:
-            # this is a bit brutal, but easier in this context than the alternative.
+            # this is a bit brutal, but easier in this context than the
+            # alternative.
             call(['killall', 'gedit'])
 
     def test_wait_for_app_running_works(self):
@@ -49,7 +51,8 @@
         start = time()
         t = Thread(target=start_gedit())
         t.start()
-        ret = self.process_manager.wait_until_application_is_running('gedit.desktop', 10)
+        ret = self.process_manager.wait_until_application_is_running(
+            'gedit.desktop', 10)
         end = time()
         t.join()
 
@@ -57,11 +60,13 @@
         self.assertThat(abs(end - start - 5.0), LessThan(1))
 
     def test_wait_for_app_running_times_out_correctly(self):
-        """Make sure the bamf emulator times out correctly if no app is started."""
+        """Make sure the bamf emulator times out correctly if no app is
+        started."""
         self.ensure_gedit_not_running()
 
         start = time()
-        ret = self.process_manager.wait_until_application_is_running('gedit.desktop', 5)
+        ret = self.process_manager.wait_until_application_is_running(
+            'gedit.desktop', 5)
         end = time()
 
         self.assertThat(abs(end - start - 5.0), LessThan(1))
@@ -103,4 +108,3 @@
         # bug:1174911)
         ret_code = call(["pgrep", "-c", "gnome-calculato"])
         self.assertThat(ret_code, Equals(1), "Application is still running")
-