Merge lp:~noskcaj/ubuntu-autopilot-tests/pep8 into lp:ubuntu-autopilot-tests

[Jackson Doak]

Make all tests pep8 compliant

[Dan Chapman  (dpniel)]

Nice one Jackson!, looks good to me :-) Thanks :-)

review: Approve

=== modified file 'ubuntu_autopilot_tests/eog/test_eog.py'
--- ubuntu_autopilot_tests/eog/test_eog.py	2013-07-11 11:23:20 +0000
+++ ubuntu_autopilot_tests/eog/test_eog.py	2013-11-23 00:24:47 +0000
@@ -5,80 +5,87 @@
 from autopilot.input import Mouse, Touch, Pointer
 
 
-
 class EogTests(AutopilotTestCase):
-    
+
     def setUp(self):
         super(EogTests, self).setUp()
-        
+
         image_name = 'logo-ubuntu_su-orange-hex.jpg'
         for root, dirs, files in os.walk(os.getcwd()):
             for name in files:
                 if name == image_name:
                     img_path = os.path.abspath(os.path.join(root, name))
-        #Lets auto load the image as we dn't have access to the global menu             
+        #Lets auto load the image as we dn't have access to the global menu
         self.app = self.launch_test_application('eog', img_path)
-        
+
         self.pointing_device = Pointer(Mouse.create())
         self.get_eog_objects()
-        
+
     def test_display_image(self):
         #check that the image loaded
         self.assertThat(self.eog_window.title,
                         Eventually(Contains('logo-ubuntu_su-orange-hex.jpg')))
-    
+
     def test_zoom_image(self):
         self.pointing_device.move_to_object(self.normal_size_button)
         self.pointing_device.click()
         self.assertThat(self.status_label.label, Eventually(Contains('100%')))
-        
+
         self.pointing_device.move_to_object(self.zoom_in_button)
         self.pointing_device.click()
         self.assertThat(self.status_label.label, Eventually(Contains('200%')))
-        
+
         self.pointing_device.move_to_object(self.zoom_out_button)
         self.pointing_device.click()
         self.assertThat(self.status_label.label, Eventually(Contains('100%')))
-                                                                     
+
     def test_show_prev_and_next_images(self):
-        
+
         self.pointing_device.move_to_object(self.previous_button)
         self.pointing_device.click()
         self.assertThat(self.eog_window.title,
-                        Eventually(Contains('logo-ubuntu_st_no-white_orangecof-hex')))
-        self.pointing_device.click()
-        self.assertThat(self.eog_window.title,
-                        Eventually(Contains('logo-ubuntu_st_no-black_orange-hex')))
-        
-        self.pointing_device.click()
-        self.assertThat(self.eog_window.title,
-                        Eventually(Contains('logo-ubuntu_cof-orange-hex')))
+                        Eventually(Contains(
+                            'logo-ubuntu_st_no-white_orangecof-hex')))
+        self.pointing_device.click()
+        self.assertThat(self.eog_window.title,
+                        Eventually(Contains(
+                            'logo-ubuntu_st_no-black_orange-hex')))
+
+        self.pointing_device.click()
+        self.assertThat(self.eog_window.title,
+                        Eventually(Contains(
+                            'logo-ubuntu_cof-orange-hex')))
         #test we can go forward
         self.pointing_device.move_to_object(self.next_button)
         self.pointing_device.click()
         self.assertThat(self.eog_window.title,
-                        Eventually(Contains('logo-ubuntu_st_no-black_orange-hex')))
-        self.pointing_device.click()
-        self.assertThat(self.eog_window.title,
-                        Eventually(Contains('logo-ubuntu_st_no-white_orangecof-hex')))
-        self.pointing_device.click()
-        self.assertThat(self.eog_window.title,
-                        Eventually(Contains('logo-ubuntu_su-orange-hex.jpg')))
-    
+                        Eventually(Contains(
+                            'logo-ubuntu_st_no-black_orange-hex')))
+        self.pointing_device.click()
+        self.assertThat(self.eog_window.title,
+                        Eventually(Contains(
+                            'logo-ubuntu_st_no-white_orangecof-hex')))
+        self.pointing_device.click()
+        self.assertThat(self.eog_window.title,
+                        Eventually(Contains(
+                            'logo-ubuntu_su-orange-hex.jpg')))
+
     def test_rotate_image(self):
         self.pointing_device.move_to_object(self.normal_size_button)
         self.assertThat(self.status_label.label, Contains('64 pixels'))
-        
+
         self.pointing_device.move_to_object(self.rotate_left_button)
         self.pointing_device.click()
-        
-        self.assertThat(self.status_label.label, Eventually(Contains('284 pixels')))
-        
+
+        self.assertThat(self.status_label.label,
+                        Eventually(Contains('284 pixels')))
+
         self.pointing_device.move_to_object(self.rotate_right_button)
         self.pointing_device.click()
-        
-        self.assertThat(self.status_label.label, Eventually(Contains('64 pixels')))
-        
+
+        self.assertThat(self.status_label.label,
+                        Eventually(Contains('64 pixels')))
+
     def get_eog_objects(self):
         #----------------------------------------------------------------#
         #             EOG WINDOW OBJECT                                  #
@@ -88,27 +95,26 @@
         #             EOG TOOLBAR OBJECTS                                #
         #                                                                #
         self.eog_toolbar = self.eog_window.select_single('EggEditableToolbar')
-        self.previous_button = self.eog_toolbar.select_single('GtkLabel',
-                                                              label='Previous')
-        self.next_button = self.eog_toolbar.select_single('GtkLabel',
-                                                          label='Next')
-        self.zoom_in_button = self.eog_toolbar.select_single('GtkToolButton',
-                                                             label='In')
-        self.zoom_out_button = self.eog_toolbar.select_single('GtkToolButton',
-                                                              label='Out')
-        self.normal_size_button = self.eog_toolbar.select_single('GtkToolButton',
-                                                                 label='Normal')
-        self.fit_window_button = self.eog_toolbar.select_single('GtkToolButton',
-                                                                label='Fit')
-        self.rotate_left_button = self.eog_toolbar.select_single('GtkToolButton',
-                                                                 label='Left')
-        self.rotate_right_button = self.eog_toolbar.select_single('GtkToolButton',
-                                                                  label='Right')
-        
+        self.previous_button = self.eog_toolbar.select_single(
+            'GtkLabel', label='Previous')
+        self.next_button = self.eog_toolbar.select_single(
+            'GtkLabel', label='Next')
+        self.zoom_in_button = self.eog_toolbar.select_single(
+            'GtkToolButton', label='In')
+        self.zoom_out_button = self.eog_toolbar.select_single(
+            'GtkToolButton', label='Out')
+        self.normal_size_button = self.eog_toolbar.select_single(
+            'GtkToolButton', label='Normal')
+        self.fit_window_button = self.eog_toolbar.select_single(
+            'GtkToolButton', label='Fit')
+        self.rotate_left_button = self.eog_toolbar.select_single(
+            'GtkToolButton', label='Left')
+        self.rotate_right_button = self.eog_toolbar.select_single(
+            'GtkToolButton', label='Right')
+
         #-----------------------------------------------------------------#
         #           EOG STATUS BAR OBJECTS                                #
         #                                                                 #
         self.eog_statusbar = self.eog_window.select_single('EogStatusbar')
         self.statusbar_frame = self.eog_statusbar.select_single('GtkFrame')
         self.status_label = self.statusbar_frame.select_single('GtkLabel')
-        
\ No newline at end of file

=== modified file 'ubuntu_autopilot_tests/evince/test_evince.py'
--- ubuntu_autopilot_tests/evince/test_evince.py	2013-07-03 18:56:05 +0000
+++ ubuntu_autopilot_tests/evince/test_evince.py	2013-11-23 00:24:47 +0000
@@ -7,103 +7,108 @@
 from time import sleep
 
 import os
- 
 
- 
 
 class EvinceTests(AutopilotTestCase):
- 
+
     def setUp(self):
         super(EvinceTests, self).setUp()
         self.app = self.launch_test_application('evince')
 
-        self.windowTitle = self.app.select_single('EvWindow') 
-        self.prev_button = self.app.select_single('GtkButton', tooltip_text='Go to the previous page')
-        self.next_button = self.app.select_single('GtkButton', tooltip_text='Go to the next page')
-        self.page_num_box = self.app.select_single('GtkBox', tooltip_text='Select Page')
-        self.search_button = self.app.select_single('GtkToggleButton',
-                                                    tooltip_text='Find a word or phrase in the document')
+        self.windowTitle = self.app.select_single(
+            'EvWindow')
+        self.prev_button = self.app.select_single(
+            'GtkButton', tooltip_text='Go to the previous page')
+        self.next_button = self.app.select_single(
+            'GtkButton', tooltip_text='Go to the next page')
+        self.page_num_box = self.app.select_single(
+            'GtkBox', tooltip_text='Select Page')
+        self.search_button = self.app.select_single(
+            'GtkToggleButton',
+            tooltip_text='Find a word or phrase in the document')
         self.entry = self.page_num_box.get_children_by_type('GtkEntry')[0]
         self.pointing_device = Pointer(Mouse.create())
-        
+
     def test_display_pdf_file(self):
         '''test to view a pdf file'''
-    
+
         #open the created temp file
         self.open_temp_file()
-        #Grab evince window       
-        
+        #Grab evince window
+
         #test file name is in the window title bar
-        self.assertThat(self.windowTitle.title, Eventually(Contains('EvinceTestPdf.pdf')))
+        self.assertThat(self.windowTitle.title,
+                        Eventually(Contains('EvinceTestPdf.pdf')))
         # delete the temp file
-                
+
     def test_changing_pages(self):
         #Lets test we can go up and down the pages
-        
+
         self.open_temp_file()
-        self.assertThat(self.windowTitle.title, Eventually(Contains('EvinceTestPdf.pdf')))
+        self.assertThat(self.windowTitle.title,
+                        Eventually(Contains('EvinceTestPdf.pdf')))
         # move to page 2
         self.pointing_device.move_to_object(self.next_button)
         self.pointing_device.click()
         self.assertThat(self.entry.text, Eventually(Contains('2')))
-        
-        
+
         self.pointing_device.move_to_object(self.prev_button)
         self.pointing_device.click()
-        
+
         self.assertThat(self.entry.text, Eventually(Contains('1')))
-        
-        
-        
+
     def test_sidebar_open_close(self):
         #Lets test we can open and close the sidebar
         self.open_temp_file()
-        self.assertThat(self.windowTitle.title, Eventually(Contains('EvinceTestPdf.pdf')))
+        self.assertThat(self.windowTitle.title,
+                        Eventually(Contains('EvinceTestPdf.pdf')))
         # test opening and closing of sidebar
         self.change_sidebar_state()
         self.change_sidebar_state()
-                
-        
-    
+
     def test_search_document(self):
         #lets test we can search a document
         self.open_temp_file()
-        self.assertThat(self.windowTitle.title, Eventually(Contains('EvinceTestPdf.pdf')))
+        self.assertThat(self.windowTitle.title,
+                        Eventually(Contains('EvinceTestPdf.pdf')))
         #click search toggle button
         self.pointing_device.move_to_object(self.search_button)
         self.pointing_device.click()
         # Enter a search query
         self.keyboard.type('Welcome')
         # check it found the the search query
-        self.search_result_label = self.app.select_single('GtkLabel', label='1 found on this page')
-        self.assertThat(self.search_result_label.label, Eventually(Contains('1 found on this page')))
-        
-        
- 
+        self.search_result_label = self.app.select_single(
+            'GtkLabel', label='1 found on this page')
+        self.assertThat(self.search_result_label.label,
+                        Eventually(Contains('1 found on this page')))
+
     def change_sidebar_state(self):
         ''' changes the state of the sidebar and tests that it changed '''
         # get value of Evsidebar.visible
         self.side_bar = self.app.select_single('EvSidebar')
         visible = self.side_bar.visible
-        # Test and change the side bar, 
+        # Test and change the side bar,
         if visible == 1:
             self.keyboard.press_and_release('F9')
             self.assertThat(self.side_bar.visible, Equals(0))
         else:
             self.keyboard.press_and_release('F9')
             self.assertThat(self.side_bar.visible, Equals(1))
-    
+
     def open_temp_file(self):
         '''Opens the EvinceTestPdf.pdf file'''
         # Click on the settings button
-        self.settings_button = self.app.select_single('GtkImage', icon_name='emblem-system-symbolic')
+        self.settings_button = self.app.select_single(
+            'GtkImage', icon_name='emblem-system-symbolic')
         self.pointing_device.move_to_object(self.settings_button)
         self.pointing_device.click()
         # press 'O' to open the file dialog
         self.keyboard.press_and_release("o")
-        # check the file dialog opened and contains 'Open Document' in the window title
+        # check the file dialog opened and
+        # 'Open Document' is in the window title
         self.open_file_dialog = self.app.select_single('GtkFileChooserDialog')
-        self.assertThat(self.open_file_dialog.title, Eventually(Equals('Open Document')))
+        self.assertThat(self.open_file_dialog.title,
+                        Eventually(Equals('Open Document')))
         # enter the file name and location
         self.keyboard.press_and_release("Ctrl+a")
         self.keyboard.type('/')
@@ -117,10 +122,3 @@
                     self.keyboard.type(test_pdf)
         # click on the 'open' button
         self.keyboard.press_and_release('Enter')
-        
-    
-
-    
-    
-    
-

=== modified file 'ubuntu_autopilot_tests/fileroller/test_fileroller.py'
--- ubuntu_autopilot_tests/fileroller/test_fileroller.py	2013-05-31 08:54:51 +0000
+++ ubuntu_autopilot_tests/fileroller/test_fileroller.py	2013-11-23 00:24:47 +0000
@@ -7,6 +7,7 @@
 import shutil
 import tempfile
 
+
 class FileRollerTests(AutopilotTestCase):
     '''Collection of autopilot test for file-roller (Archive Manager) '''
 
@@ -16,67 +17,78 @@
         self.app = self.launch_test_application('file-roller')
 
         # only instantiate these once for multiple tests
-        # these can only be instantiated here if you do not need to reload the application during a test
-        # As the Gtk id's change when application is relaunched. and throws error
-        # So for tests that are reloaded also grab new Gtkobject id's after relaunch
+        # these can only be instantiated here if you do not need to reload the
+        # application during a test
+        # As the Gtk ids change when application is relaunched and throws error
+        # So for tests that are reloaded also grab
+        # new Gtkobject id's after relaunch
         self.pointing_device = Pointer(Mouse.create())
         self.archiveWindow = self.app.select_single('FrWindow')
-        self.add_files_button = self.app.select_single('GtkLabel', label=u'Add Files')
-        self.extract_button = self.app.select_single('GtkLabel', label=u'Extract')
+        self.add_files_button = self.app.select_single('GtkLabel',
+                                                       label=u'Add Files')
+        self.extract_button = self.app.select_single('GtkLabel',
+                                                     label=u'Extract')
         self.open_button = self.app.select_single('GtkLabel', label=u'Open')
-        self.new_archive_button = self.app.select_single('GtkToolButton', name=u'New')
-        
+        self.new_archive_button = self.app.select_single('GtkToolButton',
+                                                         name=u'New')
+
     def test_create_archive(self):
-        '''Creates an archive and adds sample data, Window title must contain archive name'''
-        
+        '''Creates an archive and adds sample data,
+           Window title must contain archive name'''
+
         tempArchive = _tempArchiveName()
         #Test: Archive must be created with sample data
         self.create_archive_with_sample_data(tempArchive)
         # If create archive successfull, then check here that the window title
         # is the name of the archive.
         (dirName, fileName) = os.path.split(tempArchive)
-        self.assertThat(self.archiveWindow.title, Eventually(Contains(fileName)))
-        
+        self.assertThat(self.archiveWindow.title,
+                        Eventually(Contains(fileName)))
+
         #Cleanup
         self.delete_temp_archive()
-        
-        
-        
+
     def test_open_archive(self):
         '''Open archive window title must contains the archive name '''
-        
+
         tempArchive = _tempArchiveName()
-        # Call create and relaunch to get a safe way of reloading an application
+        # Call create and relaunch to get
+        # a safe way of reloading an application
         self.create_and_relaunch(tempArchive)
-               
+
         #Test: Must open archive
         self.open_test_archive(tempArchive)
         # if open archive successful, then check here that the window title
         # is the name of the archive.
         (dirName, fileName) = os.path.split(tempArchive)
-        self.assertThat(self.archiveWindow.title, Eventually(Contains(fileName)))
+        self.assertThat(self.archiveWindow.title,
+                        Eventually(Contains(fileName)))
         # Cleanup
         self.delete_temp_archive()
-        
+
     def test_extract_archive(self):
         '''Open archive and extract file'contents,'''
-        
+
         tempArchive = _tempArchiveName()
-        # Call create and relaunch to get a safe way of reloading an application
+        # Call create and relaunch to get
+        # a safe way of reloading an application
         self.create_and_relaunch(tempArchive)
-        self.assertThat(self.archiveWindow.title, Eventually(Contains('Archive Manager')))
+        self.assertThat(self.archiveWindow.title,
+                        Eventually(Contains('Archive Manager')))
         #Test: Open and extract an archive
         self.extract_test_archive(tempArchive)
         ## assert we have come back to main window after extraction
         ## Test Will not get back to mainWindow if extraction failed.
         ## Check window title is same as archive
         (dirName, fileName) = os.path.split(tempArchive)
-        self.assertThat(self.archiveWindow.title, Eventually(Contains(fileName)))
+        self.assertThat(self.archiveWindow.title,
+                        Eventually(Contains(fileName)))
         #Cleanup
         self.delete_temp_archive()
         self.delete_temp_directory(fileName)
-        
-    # this method needs some more assertions. At the moment its relying that commands are correct
+
+    # this method needs some more assertions.
+    # At the moment its relying that commands are correct
     def create_archive_with_sample_data(self, tempArchive):
         ''' Must create archive and add sample data'''
         #Click on the new archive button
@@ -84,7 +96,8 @@
         self.pointing_device.click()
         # The new archive dialog window title must have 'New Archive'
         self.new_dialog = self.app.select_single('FrNewArchiveDialog')
-        self.assertThat(self.new_dialog.title, Eventually(Equals(u'New Archive')))
+        self.assertThat(self.new_dialog.title,
+                        Eventually(Equals(u'New Archive')))
 
         #Enter name of new archive
         self.keyboard.type(tempArchive)
@@ -92,7 +105,8 @@
         # TODO: Figure out a gzip commpress, does not have an active Id enabled
 
         # select the create button and check it is clickable
-        self.create_button = self.app.select_single('GtkButton', label=u'create-archive')
+        self.create_button = self.app.select_single('GtkButton',
+                                                    label=u'create-archive')
         self.assertThat(self.create_button.label, Eventually(NotEquals(None)))
         # Click on Create button
         self.pointing_device.move_to_object(self.create_button)
@@ -102,11 +116,15 @@
         self.pointing_device.click()
         # The add files dialog title must contain 'Add Files'
         self.add_files_dialog = self.app.select_single('FrFileSelectorDialog')
-        self.assertThat(self.add_files_dialog.title, Eventually(Equals('Add Files')))
+        self.assertThat(self.add_files_dialog.title,
+                        Eventually(Equals('Add Files')))
 
-        # This is a horrible hacky workaround to add sample files from /usr/share/example-content/*
-        # Need to find a better workaround :S Location GtkEntry doesnt work when entering file path
-        # Maybe add some assertions to check that the Location GTKEntry contains correct path
+        # This is a horrible hacky workaround to add sample
+        # files from /usr/share/example-content/*
+        # Need to find a better workaround :S Location GtkEntry
+        # doesnt work when entering file path
+        # Maybe add some assertions to check that the
+        # Location GTKEntry contains correct path
         self.keyboard.press_and_release("Alt+l")
         self.keyboard.press_and_release("Tab")
         self.keyboard.press_and_release("Tab")
@@ -125,14 +143,16 @@
         self.keyboard.press_and_release("Left")
         self.keyboard.press_and_release("Enter")
         # We must be able to click the '_Add' button
-        self.add_folder_button = self.app.select_single('GtkLabel', label=u'_Add')
-        self.assertThat(self.add_folder_button.label, Eventually(NotEquals(None)))
+        self.add_folder_button = self.app.select_single('GtkLabel',
+                                                        label=u'_Add')
+        self.assertThat(self.add_folder_button.label,
+                        Eventually(NotEquals(None)))
         #Click the '_Add" button
         self.pointing_device.move_to_object(self.add_folder_button)
         self.pointing_device.click()
         # sleep needed to give sample data enough time to be added
         sleep(10)
-        
+
     # Method for opening an archive, needs assertions adding
     def open_test_archive(self, tempArchive):
         '''Open the test archive'''
@@ -142,19 +162,20 @@
 
         self.keyboard.press_and_release("Alt+l")
         self.keyboard.type(tempArchive)
-        
 
-        self.open_archive_button = self.app.select_single('GtkLabel', label=u'_Open')
+        self.open_archive_button = self.app.select_single(
+            'GtkLabel', label=u'_Open')
         self.pointing_device.move_to_object(self.open_archive_button)
         self.pointing_device.click()
 
     def extract_test_archive(self, tempArchive):
         '''Open Archive and extract the sample data'''
-        
+
         self.open_test_archive(tempArchive)
         (dirName, fileName) = os.path.split(tempArchive)
 
-        self.assertThat(self.archiveWindow.title, Eventually(Contains(fileName)))
+        self.assertThat(self.archiveWindow.title,
+                        Eventually(Contains(fileName)))
 
         # Check that the Extract button is now clickable
         self.assertThat(self.extract_button.label, Eventually(NotEquals(None)))
@@ -166,49 +187,60 @@
         self.keyboard.press_and_release("Alt+l")
         self.keyboard.type(tempArchive)
 
-        self.extract_archive_button = self.app.select_single('GtkLabel', label=u'_Extract')
-        self.assertThat(self.extract_archive_button.label, Eventually(NotEquals(None)))
+        self.extract_archive_button = self.app.select_single(
+            'GtkLabel', label=u'_Extract')
+        self.assertThat(self.extract_archive_button.label,
+                        Eventually(NotEquals(None)))
 
         self.pointing_device.move_to_object(self.extract_archive_button)
         self.pointing_device.click()
-        # need this sleep to give enough time for the GtkDialog time to load before
-        # we can select it
+        # need this sleep to give enough time for the GtkDialog time to load
+        # before we can select it
         sleep(10)
         self.extract_dialog = self.app.select_single('GtkDialog')
-        self.assertThat(self.extract_dialog.title, Eventually(Contains(u"")))
-        self.show_files_button = self.app.select_single('GtkLabel', label=u'_Show the Files')
-        self.assertThat(self.show_files_button.label, Eventually(NotEquals(None)))
+        self.assertThat(self.extract_dialog.title,
+                        Eventually(Contains(u"")))
+        self.show_files_button = self.app.select_single(
+            'GtkLabel', label=u'_Show the Files')
+        self.assertThat(self.show_files_button.label,
+                        Eventually(NotEquals(None)))
 
         self.pointing_device.move_to_object(self.show_files_button)
         self.pointing_device.click()
-        # This sleep is needed as we can't introspect nautilus when it shows the files
+        # This sleep is needed as we can't introspect
+        # nautilus when it shows the files
         # TODO: Once nautilus can be introspected we need to lose this sleep
         # and confirm nautilus window title Eventually Contains fileName
         sleep(10)
 
         self.keyboard.press_and_release("Alt+F4")
-        
+
     def create_and_relaunch(self, tempArchive):
         ''' This method calls create archive_with_sample_data
-            then will close the application and relaunch it 
+            then will close the application and relaunch it
             grabbing new Gtk object id's'''
         # Create archive and check window title
         self.create_archive_with_sample_data(tempArchive)
         (dirName, fileName) = os.path.split(tempArchive)
 
-        self.assertThat(self.archiveWindow.title, Eventually(Contains(fileName)))
+        self.assertThat(self.archiveWindow.title,
+                        Eventually(Contains(fileName)))
         # Close the Application
         self.keyboard.press_and_release('Ctrl+w')
         # launch a new instance of fire-roller
         self.app = self.launch_test_application('file-roller')
-        # We need to get the new object id's here as we have reloaded the application and
-        # will throw an error unknown id if we don't :)
+        # We need to get the new object id's here as we have reloaded the
+        # application and will throw an error unknown id if we don't :)
         self.archiveWindow = self.app.select_single('FrWindow')
-        self.add_files_button = self.app.select_single('GtkLabel', label=u'Add Files')
-        self.extract_button = self.app.select_single('GtkLabel', label=u'Extract')
-        self.open_button = self.app.select_single('GtkLabel', label=u'Open')
-        self.new_archive_button = self.app.select_single('GtkToolButton', name=u'New')
-    
+        self.add_files_button = self.app.select_single(
+            'GtkLabel', label=u'Add Files')
+        self.extract_button = self.app.select_single(
+            'GtkLabel', label=u'Extract')
+        self.open_button = self.app.select_single(
+            'GtkLabel', label=u'Open')
+        self.new_archive_button = self.app.select_single(
+            'GtkToolButton', name=u'New')
+
     def delete_temp_archive(self):
         # Cleanup
         temp = self.archiveWindow.title
@@ -216,17 +248,16 @@
         temp = temp.strip()
         path = os.path.join('/tmp/'+temp)
         self.addCleanup(os.unlink, path)
-        
-    def delete_temp_directory(self, fileName ):
+
+    def delete_temp_directory(self, fileName):
         #Delete the extracted directory
-        extract_path = os.path.join('/tmp/'+ fileName)
+        extract_path = os.path.join('/tmp/' + fileName)
         self.addCleanup(shutil.rmtree, extract_path)
-    
-    
+
+
 #hardcoded global archiveName
 def _tempArchiveName():
     '''Temporary archive name for testing with.'''
     sFile = tempfile.NamedTemporaryFile()
     sFile.close()
     return sFile.name
-

=== modified file 'ubuntu_autopilot_tests/firefox/test_firefox.py'
--- ubuntu_autopilot_tests/firefox/test_firefox.py	2013-07-17 11:39:59 +0000
+++ ubuntu_autopilot_tests/firefox/test_firefox.py	2013-11-23 00:24:47 +0000
@@ -1,14 +1,18 @@
-#Note: This testcase avoids using introspection because autopilot-gtk fails to introspect firefox properly
+# Note: This testcase avoids using introspection because autopilot-gtk
+# fails to introspect firefox properly
 from autopilot.testcase import AutopilotTestCase
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals, Contains
 from autopilot.process import ProcessManager
 
-#register firefox as an application so we can call it
-ProcessManager.register_known_application("Firefox", "firefox.desktop", "firefox")
-#lets force firefox to load jenkins page rather than getting autopilot to type.
+# register firefox as an application so we can call it
+ProcessManager.register_known_application(
+    "Firefox", "firefox.desktop", "firefox")
+# lets force firefox to load jenkins page rather than getting autopilot to
+# type.
 URLS = ['http://jenkins.qa.ubuntu.com']
 
+
 class FirefoxTests(AutopilotTestCase):
 
     def setUp(self):
@@ -16,81 +20,85 @@
         self.manager = ProcessManager.create('BAMF')
         self.app = self.manager.start_app_window("Firefox", URLS)
 
-        #make sure firefox is up and loaded
+        # make sure firefox is up and loaded
         self.app.set_focus()
         self.assertTrue(self.app.is_focused)
 
     def test_firefox_works(self):
-        #Test-case name: firefox/fir-001
-        #This test will check that Firefox can display webpages
-
-        #check that page title loaded jenkins
-        self.assertThat(lambda: self.app.name, Eventually(Contains("Jenkins"), timeout=30))
-        
-        #This test will check that Firefox can create tabs and windows
-        self.assertThat(lambda: self.app.name,
-                        Eventually(Contains("Jenkins"), timeout=30))
-
-        #test fullscreen
+        # Test-case name: firefox/fir-001
+        # This test will check that Firefox can display webpages
+
+        # check that page title loaded jenkins
+        self.assertThat(lambda: self.app.name,
+                        Eventually(Contains("Jenkins"), timeout=30))
+
+        # This test will check that Firefox can create tabs and windows
+        self.assertThat(lambda: self.app.name,
+                        Eventually(Contains("Jenkins"), timeout=30))
+
+        # test fullscreen
         self.keyboard.press_and_release("F11")
-    
-        #verify fullscreen
-        #Does Firefox enter fullscreen mode?
+
+        # verify fullscreen
+        # Does Firefox enter fullscreen mode?
         self.assertThat(lambda: self.app._get_window_states(),
                         Eventually(Contains("_NET_WM_STATE_FULLSCREEN")))
-        
-        #go back to normal
+
+        # go back to normal
         self.keyboard.press_and_release("F11")
-        
-        
-        #open new tab
+
+        # open new tab
         self.keyboard.press_and_release("Ctrl+t")
-    
-        #check that page title reflects new tab
-        self.assertThat(lambda: self.app.name, Eventually(Equals("Mozilla Firefox")))
-    
-        #close new tab
+
+        # check that page title reflects new tab
+        self.assertThat(lambda: self.app.name,
+                        Eventually(Equals("Mozilla Firefox")))
+
+        # close new tab
         self.keyboard.press_and_release("Ctrl+w")
-        #check we are back to one tab
-        self.assertThat(lambda: self.app.name, Eventually(Contains("Jenkins")))
-        
-        #open new window
-        originalWindowCount = len(self.manager.get_open_windows_by_application("Firefox"))
+        # check we are back to one tab
+        self.assertThat(lambda: self.app.name,
+                        Eventually(Contains("Jenkins")))
+
+        # open new window
+        originalWindowCount = len(
+            self.manager.get_open_windows_by_application("Firefox"))
         self.keyboard.press_and_release("Ctrl+n")
-    
-        #check that we spawned a new window; we use window count so this works even if you have firefox already running (shouldn't happen in a sterile labe enviroment however)
-        self.assertThat(lambda: len(self.manager.get_open_windows_by_application("Firefox")),
-                        Eventually(Equals(originalWindowCount + 1)))
-    
-        #close window
+
+        # check that we spawned a new window; we use window count so this works
+        # even if you have firefox already running
+        # (shouldn't happen in a sterile labe enviroment however)
+        self.assertThat(
+            lambda: len(
+                self.manager.get_open_windows_by_application("Firefox")),
+            Eventually(Equals(originalWindowCount + 1)))
+
+        # close window
         self.keyboard.press_and_release("Ctrl+w")
-        #check we have gone back to one window
-        self.assertThat(lambda: len(self.manager.get_open_windows_by_application("Firefox")),
-                        Eventually(Equals(originalWindowCount)))
-
-    
-        #Test-case name: firefox/fir-002
-        #This test will check that Firefox can display search suggestions
-    
-        #open search box, switch to google
+        # check we have gone back to one window
+        self.assertThat(lambda: len(
+            self.manager.get_open_windows_by_application("Firefox")),
+            Eventually(Equals(originalWindowCount)))
+
+        # Test-case name: firefox/fir-002
+        # This test will check that Firefox can display search suggestions
+
+        # open search box, switch to google
         self.keyboard.press_and_release("Ctrl+k")
         self.keyboard.press_and_release("F4")
         self.keyboard.press_and_release("g")
-    
-        #search for ubuntu server docs
+
+        # search for ubuntu server docs
         self.keyboard.type("ubuntu server docs")
-    
-        #ensure we have a generated list of suggestions
-        #WE CAN'T DO THIS :-(
-    
-        #go to results page
+
+        # ensure we have a generated list of suggestions
+        # WE CAN'T DO THIS :-(
+
+        # go to results page
         self.keyboard.type("\n")
-    
-        #check results by looking at page title
+
+        # check results by looking at page title
         self.assertThat(lambda: self.app.name, Eventually(Contains("Google")))
-        
-        self.assertThat(lambda: self.app.name, Eventually(Contains("server docs")))
-    
-    
- 
-        
+
+        self.assertThat(lambda: self.app.name,
+                        Eventually(Contains("server docs")))

=== modified file 'ubuntu_autopilot_tests/gedit/__init__.py'
--- ubuntu_autopilot_tests/gedit/__init__.py	2013-08-13 18:51:02 +0000
+++ ubuntu_autopilot_tests/gedit/__init__.py	2013-11-23 00:24:47 +0000
@@ -17,7 +17,8 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 from autopilot.testcase import AutopilotTestCase
 from autopilot.matchers import Eventually
-from testtools.matchers import Equals, NotEquals, Contains, FileExists, FileContains
+from testtools.matchers import Equals, NotEquals, Contains, FileExists, \
+    FileContains
 from autopilot.input import Pointer, Mouse
 import tempfile
 import os
@@ -29,55 +30,67 @@
         super(GeditAutopilotTestCase, self).setUp()
         self.app = self.launch_test_application("gedit")
         self.pointing_device = Pointer(Mouse.create())
-        
-    def setup_test_docs(self,num_of_docs,text=False,
-                        tab_num=1,save_dlg=False,
-                        opn_dlg=False,replace_dlg=False,
-                        print_dlg=False,print_preview=False):
-        """ This function sets up the pre-reqs for a test
-            
-            Using a combination of these params you can set up different
-            situations for testing
-            
-            params:
-            num_of_docs: *Required* an int value of the number of docs
-                         needed for the test
-            text=: Set to False by default if set to true will add text
-                   to each document.
-            tab_num=: Sets the tab focus to the given tab number on setup.
-                      Set to 1 by default
-            save_dlg=: If set to True Sets the save dialog up in the
-                       gedit/samples directory for the test
-            opn_dlg=: If set to True sets the open dialog up for test
-            print_dlg=: If set to True sets the print dialog up for printing to a file
-            print_preview=: If set to True sets the Print preview dialog up for testing
+
+    def setup_test_docs(self, num_of_docs, text=False,
+                        tab_num=1, save_dlg=False,
+                        opn_dlg=False, replace_dlg=False,
+                        print_dlg=False, print_preview=False):
+        """
+        This function sets up the pre-reqs for a test
+
+        Using a combination of these params you can set up different
+        situations for testing
+
+        params:
+        num_of_docs: *Required* an int value of the number of docs
+                     needed for the test
+        text=: Set to False by default if set to true will add text
+               to each document.
+        tab_num=: Sets the tab focus to the given tab number on setup.
+                  Set to 1 by default
+        save_dlg=: If set to True Sets the save dialog up in the
+                   gedit/samples directory for the test
+        opn_dlg=: If set to True sets the open dialog up for test
+        print_dlg=: If set to True sets the print
+                    dialog up for printing to a file
+        print_preview=: If set to True sets the Print preview
+                        dialog up for testing
         """
         # gedit by default loads a blank document
         # so start num at 1
         num = 1
         txt = text
-        
-        if txt == True:
+
+        if txt is True:
             view = self.app.select_single('GeditView')
             self.assertThat(view.is_focus, Equals(1))
-            self.keyboard.type('Document %s: The quick brown fox jumps over the lazy dog' % str(num))
-            
-            self.assertThat(view.buffer,
-                            Equals('Document %s: The quick brown fox jumps over the lazy dog' % str(num)),
-                            "Autopilot mis-typed the phrase")
-  
+            self.keyboard.type(
+                'Document %s: The quick brown fox jumps over the lazy dog'
+                % str(num))
+
+            self.assertThat(
+                view.buffer,
+                Equals(
+                    'Document %s: The quick brown fox jumps over the lazy dog'
+                    % str(num)),
+                "Autopilot mis-typed the phrase")
+
         while num < num_of_docs:
             self.keyboard.press_and_release('Ctrl+n')
-            num +=1
-            if txt == True:
+            num += 1
+            if txt is True:
                 view = self.app.select_many('GeditView')[num - 1]
                 self.assertThat(view.is_focus, Equals(1))
-                self.keyboard.type('Document %s: The quick brown fox jumps over the lazy dog' % str(num))
-                
-                self.assertThat(view.buffer,
-                                Equals('Document %s: The quick brown fox jumps over the lazy dog' % str(num)),
-                                "Autopilot mis-typed the phrase")
-            
+                self.keyboard.type(
+                    'Document %s: The quick brown fox jumps over the lazy dog'
+                    % str(num))
+
+                self.assertThat(
+                    view.buffer,
+                    Equals(
+                        'Document %s: The quick brown fox jumps \
+                        over the lazy dog' % str(num)),
+                    "Autopilot mis-typed the phrase")
 
         # lets just check we have the right amount of tabs
         num_of_tabs = len(self.app.select_many('GeditView'))
@@ -90,65 +103,83 @@
         view = self.app.select_many('GeditView')[tab_num - 1]
         self.assertThat(view.is_focus, Eventually(Equals(1)),
                         "We are not on the correct tab")
-        if save_dlg == True:
+        if save_dlg is True:
             self.pointing_device.click_object(
-            self.app.select_single('GtkToolButton',
-                                   name='FileSave'))
-            self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                            Eventually(Equals(1)), "The save dialog did not open")
+                self.app.select_single('GtkToolButton',
+                                       name='FileSave'))
+            self.assertThat(
+                lambda: self.app.select_single(
+                    'GeditFileChooserDialog').visible,
+                Eventually(Equals(1)), "The save dialog did not open")
             dlg = self.app.select_single('GeditFileChooserDialog')
-           
-            self.pointing_device.click_object(dlg.select_single('GtkFileChooserEntry'))
-            self.assertThat(lambda: dlg.select_single('GtkFileChooserEntry').is_focus,
-                            Eventually(Equals(1)),
-                            "Entry did not get focus after being clicked")
+
+            self.pointing_device.click_object(
+                dlg.select_single('GtkFileChooserEntry'))
+            self.assertThat(
+                lambda: dlg.select_single('GtkFileChooserEntry').is_focus,
+                Eventually(Equals(1)),
+                "Entry did not get focus after being clicked")
             self.keyboard.press_and_release('Ctrl+a')
             self.keyboard.press_and_release('Delete')
-            #lets make sure we always save in /tmp
+            # lets make sure we always save in /tmp
             self.keyboard.type('/tmp/')
             self.keyboard.press_and_release('Enter')
-            
-        if opn_dlg == True:
+
+        if opn_dlg is True:
             self.pointing_device.click_object(
                 self.app.select_single('GeditOpenToolButton'))
-            self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                            Eventually(Equals(1)), "file chooser dialog did not open")
+            self.assertThat(
+                lambda: self.app.select_single(
+                    'GeditFileChooserDialog').visible,
+                Eventually(Equals(1)), "file chooser dialog did not open")
             dlg = self.app.select_single('GeditFileChooserDialog')
             self.keyboard.press_and_release('/')
-            self.assertThat(lambda: dlg.select_single('GtkFileChooserEntry').is_focus,
-                            Eventually(Equals(1)),
-                            "Entry did not get focus after being clicked")
-            #lets make sure we are in our samples dir
+            self.assertThat(
+                lambda: dlg.select_single('GtkFileChooserEntry').is_focus,
+                Eventually(Equals(1)),
+                "Entry did not get focus after being clicked")
+            # lets make sure we are in our samples dir
             sample_dir = 'samples'
             for root, dirs, files in os.walk(os.getcwd()):
                 for name in dirs:
                     if name == sample_dir:
                         dir_path = os.path.abspath(os.path.join(root, name))
-            self.keyboard.type(dir_path+"/")
-        
-        if replace_dlg == True:
+            self.keyboard.type(dir_path + "/")
+
+        if replace_dlg is True:
             self.pointing_device.click_object(
                 self.app.select_single('GtkToolButton',
                                        name='SearchReplace'))
-            self.assertThat(lambda: self.app.select_single('GeditReplaceDialog').visible,
-                            Eventually(Equals(1)),
-                            "Replace dialog did not open")
-            #lets grab all the objects we might need in the test
+            self.assertThat(
+                lambda: self.app.select_single('GeditReplaceDialog').visible,
+                Eventually(Equals(1)),
+                "Replace dialog did not open")
+            # lets grab all the objects we might need in the test
             self.rep_dialog = self.app.select_single('GeditReplaceDialog')
-            self.mtch_chkbtn = self.rep_dialog.select_single(BuilderName='match_case_checkbutton')
-            self.entire_chkbtn = self.rep_dialog.select_single(BuilderName='entire_word_checkbutton')
-            self.srch_bk_chkbtn = self.rep_dialog.select_single(BuilderName='search_backwards_checkbutton')
-            self.wrp_chkbtn = self.rep_dialog.select_single(BuilderName='wrap_around_checkbutton')
-            self.find_button = self.rep_dialog.select_single('GtkLabel', label='_Find')
-            self.replace_button = self.rep_dialog.select_single('GtkLabel', label='_Replace')
-            self.replace_all_button = self.rep_dialog.select_single('GtkLabel', label='Replace _All')
-            self.close_button = self.rep_dialog.select_single('GtkLabel', label='_Close')
-            self.search_entry = self.rep_dialog.select_single('GeditHistoryEntry', history_id='search-for-entry')
-            self.search_entry_text = self.search_entry.select_single('GtkEntry')
-            self.replace_entry = self.rep_dialog.select_single('GeditHistoryEntry', history_id='replace-with-entry')
-            self.replace_entry_text = self.replace_entry.select_single('GtkEntry')
-            #now lets select the search entry
+            self.mtch_chkbtn = self.rep_dialog.select_single(
+                BuilderName='match_case_checkbutton')
+            self.entire_chkbtn = self.rep_dialog.select_single(
+                BuilderName='entire_word_checkbutton')
+            self.srch_bk_chkbtn = self.rep_dialog.select_single(
+                BuilderName='search_backwards_checkbutton')
+            self.wrp_chkbtn = self.rep_dialog.select_single(
+                BuilderName='wrap_around_checkbutton')
+            self.find_button = self.rep_dialog.select_single(
+                'GtkLabel', label='_Find')
+            self.replace_button = self.rep_dialog.select_single(
+                'GtkLabel', label='_Replace')
+            self.replace_all_button = self.rep_dialog.select_single(
+                'GtkLabel', label='Replace _All')
+            self.close_button = self.rep_dialog.select_single(
+                'GtkLabel', label='_Close')
+            self.search_entry = self.rep_dialog.select_single(
+                'GeditHistoryEntry', history_id='search-for-entry')
+            self.search_entry_text = self.search_entry.select_single(
+                'GtkEntry')
+            self.replace_entry = self.rep_dialog.select_single(
+                'GeditHistoryEntry', history_id='replace-with-entry')
+            self.replace_entry_text = self.replace_entry.select_single(
+                'GtkEntry')
+            # now lets select the search entry
             self.pointing_device.click_object(self.search_entry)
-            #we are all set for the test now
-            
-            
\ No newline at end of file
+            # we are all set for the test now

=== modified file 'ubuntu_autopilot_tests/gedit/samples/gedit.py'
--- ubuntu_autopilot_tests/gedit/samples/gedit.py	2013-08-13 08:03:51 +0000
+++ ubuntu_autopilot_tests/gedit/samples/gedit.py	2013-11-23 00:24:47 +0000
@@ -2,5 +2,5 @@
 
 string = "Hello Autopilot\n"
 if re.search(r"[^abc]", string):
-    print (string + " contains a character other than " +\
-          "a, b, and c")
\ No newline at end of file
+    print (string + " contains a character other than " +
+           "a, b, and c")

=== modified file 'ubuntu_autopilot_tests/gedit/test_gedit.py'
--- ubuntu_autopilot_tests/gedit/test_gedit.py	2013-08-14 17:03:26 +0000
+++ ubuntu_autopilot_tests/gedit/test_gedit.py	2013-11-23 00:24:47 +0000
@@ -18,7 +18,8 @@
 from autopilot.matchers import Eventually
 from testtools import ExpectedException
 from testtools.content import Content, ContentType
-from testtools.matchers import Equals, NotEquals, Contains, FileExists, FileContains, LessThan, DirExists
+from testtools.matchers import Equals, NotEquals, Contains, \
+    FileExists, FileContains, LessThan, DirExists
 from gedit import GeditAutopilotTestCase
 from autopilot.testcase import AutopilotTestCase
 import subprocess
@@ -27,6 +28,7 @@
 import time
 import shutil
 
+
 class GeditKeyboardShortcutTests(GeditAutopilotTestCase):
 
     def test_close_tab(self, ):
@@ -34,51 +36,53 @@
         # setup 2 blank documents
         self.setup_test_docs(2)
         num_before = len(self.app.select_many('GeditView'))
-        #close tab
+        # close tab
         self.keyboard.press_and_release('Ctrl+w')
-        #did it close?
+        # did it close?
         num_after = len(self.app.select_many('GeditView'))
         self.assertThat(num_after,
                         Equals(num_before - 1),
-                        "Tab did not close correctly: %s tabs were still open"\
-                        %str(num_after))
+                        "Tab did not close correctly: %s tabs were still open"
+                        % str(num_after))
 
     def test_save_all_document_shortcut(self, ):
         """ Using shortcut Ctrl+Shift+l, test the save dialog appears """
         # create a 3 docs with some text so we can save
         self.setup_test_docs(3, text=True)
         self.keyboard.press_and_release('Ctrl+s')
-        self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                        Eventually(Equals(1)),
-                        "Save dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditFileChooserDialog').visible,
+            Eventually(Equals(1)),
+            "Save dialog did not open")
 
     def test_close_all_tabs_shortcut(self, ):
         """ Using shortcut Ctrl+Shift+W """
         self.setup_test_docs(3)
         # close all windows
         self.keyboard.press_and_release('Ctrl+Shift+w')
-        #check there are no tabs
+        # check there are no tabs
         tabs = len(self.app.select_many('GeditTab'))
-        self.assertThat(tabs, Equals(0),
-                        "Not all tabs closed: %s tabs were still open"%str(tabs))
+        self.assertThat(
+            tabs, Equals(0),
+            "Not all tabs closed: %s tabs were still open" % str(tabs))
 
     def test_jump_to_nth_tab_shortcut(self, ):
         """ Using shortcut Alt+n """
         self.setup_test_docs(3)
         # jump to tab 3
         self.keyboard.press_and_release('Alt+3')
-        #check we are on tab 3 (index 2)
+        # check we are on tab 3 (index 2)
         self.assertThat(lambda: self.app.select_many('GeditView')[2].is_focus,
                         Eventually(Equals(1)), "Tab 3 did not get focus")
 
     def test_create_new_document_shortcut(self, ):
         """ Using shortcut Ctrl+N """
-        #check that only the default tab is there
+        # check that only the default tab is there
         num_tabs = len(self.app.select_many('GeditView'))
         self.assertThat(num_tabs, Equals(1))
         # create new document
         self.keyboard.press_and_release('Ctrl+n')
-        #test new document is there and visible
+        # test new document is there and visible
         self.assertThat(num_tabs, Equals(1))
         self.assertThat(lambda: self.app.select_many('GeditView')[1].is_focus,
                         Eventually(Equals(1)), "New document was not created")
@@ -86,119 +90,140 @@
     def test_open_file_shortcut(self, ):
         """ Using shortcut Ctrl+o, test the file chooser dialog appears """
         self.keyboard.press_and_release('Ctrl+o')
-        self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                        Eventually(Equals(1)), "file chooser dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditFileChooserDialog').visible,
+            Eventually(Equals(1)), "file chooser dialog did not open")
 
     def test_save_document_shortcut(self, ):
         """ Using shortcut Ctrl+s, test the save dialog appears """
         # create a doc with some text so we can save
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+s')
-        self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                        Eventually(Equals(1)), "The save dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditFileChooserDialog').visible,
+            Eventually(Equals(1)), "The save dialog did not open")
 
     def test_save_as_shortcut(self, ):
         """ Using shortcut Ctrl+Shift+s, test the save as dialog appears """
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+Shift+s')
-        self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                        Eventually(Equals(1)), "The save dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditFileChooserDialog').visible,
+            Eventually(Equals(1)), "The save dialog did not open")
 
     def test_print_document_shortcut(self, ):
         """ Using shortcut Ctrl+p, test the print dialog appears """
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+p')
-        self.assertThat(lambda: self.app.select_single('GtkPrintUnixDialog').visible,
-                        Eventually(Equals(1)), "The print dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GtkPrintUnixDialog').visible,
+            Eventually(Equals(1)), "The print dialog did not open")
 
     def test_print_preview_shortcut(self, ):
         """ Using shortcut Ctrl+Shift+p, test the print preview appears """
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+Shift+p')
-        self.assertThat(lambda: self.app.select_single('GeditPrintPreview').visible,
-                        Eventually(Equals(1)), "The print preview window did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditPrintPreview').visible,
+            Eventually(Equals(1)), "The print preview window did not open")
 
     def test_home_key_moves_to_beginning_of_line(self, ):
         """ Using the 'Home' Key test we go to beginning of line """
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Home')
-        #lets delete the first letter in the buffer
+        # lets delete the first letter in the buffer
         self.keyboard.press_and_release('Delete')
-        #Lets check we went to beginning and deleted 'D'
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals('ocument 1: The quick brown fox jumps over the lazy dog')),
-                        "Home key did not go to beginning of line")
+        # Lets check we went to beginning and deleted 'D'
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'ocument 1: The quick brown fox jumps over the lazy dog')),
+            "Home key did not go to beginning of line")
 
     def test_end_key_goes_to_end_of_line(self, ):
         """ Using the 'End' Key test we go to end of line """
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Home')
-        #lets delete the first letter in the buffer
+        # lets delete the first letter in the buffer
         self.keyboard.press_and_release('Delete')
-        #Lets check we went to beginning and deleted 'T'
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals('ocument 1: The quick brown fox jumps over the lazy dog')))
+        # Lets check we went to beginning and deleted 'T'
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'ocument 1: The quick brown fox jumps over the lazy dog')))
         self.keyboard.press_and_release('End')
         self.keyboard.type('s')
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals('ocument 1: The quick brown fox jumps over the lazy dogs')),
-                        "Either the 'End' key did not work or autopilot \
-                        mis-typed 's': manual compare needed")
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'ocument 1: The quick brown fox jumps over the lazy dogs')
+                ),
+            "Either the 'End' key did not work or autopilot \
+            mis-typed 's': manual compare needed")
 
     def test_undo_shortcut(self, ):
         """ Using shortcut Ctrl+z, test that we undo last action """
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+z')
-        #Lets check we were able to undo the last word
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(Equals('Document 1: The quick brown fox jumps over the lazy ')),
-                        "Last word in phrase was not undone")
+        # Lets check we were able to undo the last word
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown fox jumps over the lazy ')),
+            "Last word in phrase was not undone")
 
     def test_redo_shortcut(self, ):
-        """ Using shortcut Ctrl+Shift+z, test we can redo last undone action """
+        """Using shortcut Ctrl+Shift+z, test we can redo last undone action"""
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+z')
-        #Lets undo the last word
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals('Document 1: The quick brown fox jumps over the lazy ')),
-                        "Last word in phrase was not undone")
+        # Lets undo the last word
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown fox jumps over the lazy ')),
+            "Last word in phrase was not undone")
         self.keyboard.press_and_release('Ctrl+Shift+z')
-        #Lets check we were able to redo the last word
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals('Document 1: The quick brown fox jumps over the lazy dog')),
-                        "Redo shortcut did not redo the last word in phrase")
+        # Lets check we were able to redo the last word
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown fox jumps over the lazy dog')
+                ), "Redo shortcut did not redo the last word in phrase")
 
     def test_copy_and_paste_shortcuts(self, ):
         """ Using shortcuts Ctrl+c & Ctrl+v test we can copy and paste text """
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+a')
-        #copy text
+        # copy text
         self.keyboard.press_and_release('Ctrl+c')
         self.keyboard.press_and_release('Right')
         # now paste
         self.keyboard.press_and_release('Ctrl+v')
         # did it copy and paste correctly?
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals(
-                                'Document 1: The quick brown fox jumps over the lazy dogDocument 1: The quick brown fox jumps over the lazy dog'
-                                )),
-                        "Three possible reasons for fail: \
-                        1) Ctrl+a did not select text, \
-                        2) Ctrl+c did not copy text or \
-                        3) Ctrl+v did not paste text")
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown fox jumps over the lazy dog\
+                    Document 1: The quick brown fox jumps over the lazy dog'
+                )),
+            "Three possible reasons for fail: \
+            1) Ctrl+a did not select text, \
+            2) Ctrl+c did not copy text or \
+            3) Ctrl+v did not paste text")
 
     def test_cut_shortcut(self, ):
         """ Using shortcut Ctrl+x test we can cut text """
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+a')
         self.keyboard.press_and_release('Ctrl+x')
-        #test it cut the selected text
+        # test it cut the selected text
         self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
                         Eventually(Equals('')),
                         "Two possible reasons for fail: \
@@ -211,19 +236,20 @@
         # Since this closes the application and we lose the proxy
         # before we can test its gone, we can expect the exception to
         # assert gedit quit
-        with ExpectedException(RuntimeError,
-                               "Application under test exited before the test finished!"):
+        with ExpectedException(
+                RuntimeError,
+                "Application under test exited before the test finished!"):
             gedit = self.app.select_single('GeditWindow')
             self.assertTrue(gedit, Equals(None))
 
     def test_sidebar_shortcut(self, ):
         """ Using F9 key test side panel opens/closes """
-        #test opening panel
+        # test opening panel
         self.keyboard.press_and_release('F9')
         self.assertThat(lambda: self.app.select_many('GeditPanel')[0].visible,
                         Eventually(Equals(1)),
                         "Side panel did not open after pressing F9")
-        #and close panel
+        # and close panel
         self.keyboard.press_and_release('F9')
         self.assertThat(lambda: self.app.select_many('GeditPanel')[0].visible,
                         Eventually(Equals(0)),
@@ -231,51 +257,55 @@
 
     def test_find_a_string_shortcut(self, ):
         """ Using shortcut Ctrl+f test we can search for string """
-        #Ctrl+f
+        # Ctrl+f
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+f')
         self.keyboard.type('fox\n')
-        #lets delete the highlighted word
+        # lets delete the highlighted word
         self.keyboard.press_and_release('Delete')
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals('Document 1: The quick brown  jumps over the lazy dog')),
-                        "fox was not highlighted and removed from phrase")
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown  jumps over the lazy dog')),
+            "fox was not highlighted and removed from phrase")
 
-    #TODO:
-    #def test_find_next_instance_of_string_shortcut(self, ):
+    # TODO:
+    # def test_find_next_instance_of_string_shortcut(self, ):
     #    pass
     #
-    #def test_find_previous_instance_of_string_shortcut(self, ):
+    # def test_find_previous_instance_of_string_shortcut(self, ):
     #    pass
 
     def test_search_and_replace_shortcut(self, ):
         """ Using shortcut Ctrl+h test the replace dialog opens """
         self.keyboard.press_and_release('Ctrl+h')
-        self.assertThat(lambda: self.app.select_single('GeditReplaceDialog').visible,
-                        Eventually(Equals(1)),
-                        "Replace dialog did not open")
-    #TODO:
-    #def test_clear_highlighted_text_shortcut(self, ):
-    #    #Ctrl+Shift+k
+        self.assertThat(
+            lambda: self.app.select_single('GeditReplaceDialog').visible,
+            Eventually(Equals(1)),
+            "Replace dialog did not open")
+    # TODO:
+    # def test_clear_highlighted_text_shortcut(self, ):
+    # Ctrl+Shift+k
     #    pass
     #
-    #def test_go_to_line_shortcut(self, ):
-    #    #Ctrl+i
+    # def test_go_to_line_shortcut(self, ):
+    # Ctrl+i
     #    pass
 
-class GeditWindowTests(GeditAutopilotTestCase):   
+
+class GeditWindowTests(GeditAutopilotTestCase):
 
     def test_new_document_button(self, ):
         """ Test new doc button creates a new document """
-                #check that only the default tab is there
+                # check that only the default tab is there
         num_tabs = len(self.app.select_many('GeditView'))
         self.assertThat(num_tabs, Equals(1))
         # create new document
         self.pointing_device.click_object(
             self.app.select_single('GtkToolButton',
                                    name='FileNew'))
-        #test new document is there and visible
+        # test new document is there and visible
         self.assertThat(num_tabs, Equals(1))
         self.assertThat(lambda: self.app.select_many('GeditView')[1].is_focus,
                         Eventually(Equals(1)), "New document was not created")
@@ -284,8 +314,9 @@
         """ Using open button, test the file chooser dialog appears """
         self.pointing_device.click_object(
             self.app.select_single('GeditOpenToolButton'))
-        self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                        Eventually(Equals(1)), "file chooser dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditFileChooserDialog').visible,
+            Eventually(Equals(1)), "file chooser dialog did not open")
 
     def test_save_document_button(self, ):
         """ Using save button, test the save dialog appears """
@@ -294,8 +325,9 @@
         self.pointing_device.click_object(
             self.app.select_single('GtkToolButton',
                                    name='FileSave'))
-        self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                        Eventually(Equals(1)), "The save dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditFileChooserDialog').visible,
+            Eventually(Equals(1)), "The save dialog did not open")
 
     def test_print_document_button(self, ):
         """ Using print button, test the print dialog opens """
@@ -303,8 +335,9 @@
         self.pointing_device.click_object(
             self.app.select_single('GtkToolButton',
                                    name='FilePrint'))
-        self.assertThat(lambda: self.app.select_single('GtkPrintUnixDialog').visible,
-                        Eventually(Equals(1)), "The print dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GtkPrintUnixDialog').visible,
+            Eventually(Equals(1)), "The print dialog did not open")
 
     def test_undo_button(self, ):
         """ Test undo button, undoes last action """
@@ -312,10 +345,13 @@
         self.pointing_device.click_object(
             self.app.select_single('GtkToolButton',
                                    name='EditUndo'))
-        #Lets check we were able to undo the last word
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(Equals('Document 1: The quick brown fox jumps over the lazy ')),
-                        "Last word in phrase was not undone")
+        # Lets check we were able to undo the last word
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown fox jumps over the lazy ')),
+            "Last word in phrase was not undone")
 
     def test_redo_button(self, ):
         """ Test redo button, redoes the last undo action """
@@ -323,17 +359,23 @@
         self.pointing_device.click_object(
             self.app.select_single('GtkToolButton',
                                    name='EditUndo'))
-        #Lets check we were able to undo the last word
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(Equals('Document 1: The quick brown fox jumps over the lazy ')),
-                        "Last word in phrase was not undone")
-        self.pointing_device.click_object(self.app.select_single('GtkToolButton',
-                                                                 name='EditRedo'))
-        #Lets check we were able to redo the last word
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals('Document 1: The quick brown fox jumps over the lazy dog')),
-                        "Redo shortcut did not redo the last word in phrase")
+        # Lets check we were able to undo the last word
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown fox jumps over the lazy ')),
+            "Last word in phrase was not undone")
+        self.pointing_device.click_object(
+            self.app.select_single('GtkToolButton',
+                                   name='EditRedo'))
+        # Lets check we were able to redo the last word
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown fox jumps over the lazy dog')
+                ), "Redo shortcut did not redo the last word in phrase")
 
     def test_cut_button(self, ):
         """ Test the cut button cuts the selected text """
@@ -342,7 +384,7 @@
         self.pointing_device.click_object(
             self.app.select_single('GtkToolButton',
                                    name='EditCut'))
-        #test it cut the selected text
+        # test it cut the selected text
         self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
                         Eventually(Equals('')),
                         "Two possible reasons for fail: \
@@ -353,7 +395,7 @@
         """ test we can copy and paste using buttons """
         self.setup_test_docs(1, text=True)
         self.keyboard.press_and_release('Ctrl+a')
-        #copy text
+        # copy text
         self.pointing_device.click_object(
             self.app.select_single('GtkToolButton',
                                    name='EditCopy'))
@@ -363,15 +405,17 @@
             self.app.select_single('GtkToolButton',
                                    name='EditPaste'))
         # did it copy and paste correctly?
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals(
-                                'Document 1: The quick brown fox jumps over the lazy dogDocument 1: The quick brown fox jumps over the lazy dog'
-                                )),
-                        "Three possible reasons for fail: \
-                        1) Ctrl+a did not select text, \
-                        2) Copy button did not work or \
-                        3) Paste button did not work")
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown fox jumps over the lazy dog\
+                    Document 1: The quick brown fox jumps over the lazy dog'
+                )),
+            "Three possible reasons for fail: \
+            1) Ctrl+a did not select text, \
+            2) Copy button did not work or \
+            3) Paste button did not work")
 
     def test_search_button(self, ):
         """ Test the search button opens the search box """
@@ -380,21 +424,24 @@
             self.app.select_single('GtkToolButton',
                                    name='SearchFind'))
         self.keyboard.type('fox\n')
-        #lets delete the highlighted word
+        # lets delete the highlighted word
         self.keyboard.press_and_release('Delete')
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(
-                            Equals('Document 1: The quick brown  jumps over the lazy dog')),
-                        "fox was not highlighted and removed from phrase")
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(
+                Equals(
+                    'Document 1: The quick brown  jumps over the lazy dog')),
+            "fox was not highlighted and removed from phrase")
 
     def test_search_and_replace_button(self, ):
         """ Test the replace button opens the replace dialog """
         self.pointing_device.click_object(
             self.app.select_single('GtkToolButton',
                                    name='SearchReplace'))
-        self.assertThat(lambda: self.app.select_single('GeditReplaceDialog').visible,
-                        Eventually(Equals(1)),
-                        "Replace dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditReplaceDialog').visible,
+            Eventually(Equals(1)),
+            "Replace dialog did not open")
 
     def test_window_visible(self, ):
         """ Test the window loads """
@@ -415,65 +462,66 @@
 
     # CAN WE ACCESS THE BOTTOM COMBOBOX'S????????????
 
+
 class GeditSidebarTests(GeditAutopilotTestCase):
 
     def test_close_sidebar_button(self, ):
-        #open panel
+        # open panel
         self.keyboard.press_and_release('F9')
         self.assertThat(lambda: self.app.select_many('GeditPanel')[0].visible,
                         Eventually(Equals(1)),
                         "Side panel did not open after pressing F9")
-        #and close panel using button
+        # and close panel using button
         self.pointing_device.click_object(
             self.app.select_many('GeditCloseButton')[0])
         self.assertThat(lambda: self.app.select_many('GeditPanel')[0].visible,
                         Eventually(Equals(0)),
                         "Side panel did not close after clicking close button")
 
-    #TODO: add more maybe test file browser tab and its button objects
+    # TODO: add more maybe test file browser tab and its button objects
 
 
 class GeditSaveFileTypeTests(GeditAutopilotTestCase):
-    
+
     scenarios = [
-            ('single_char', {'input': "a"}),
-            ('short_name', {'input': "test"}),
-            ('long_name', {'input': "testfilenameforgedit"}),
-            ('extra_long_name', {'input': "autopilotlongfilenamefortesting"}),
-            ('python_file', {'input': "gedit.py"}),
-            ('C_file', {'input': "gedit.c"}),
-            ('cpp_file', {'input': "gedit.cpp"}),
-            ('xml_file', {'input': "gedit.xml"}),
-            ('vala_file', {'input': "gedit.vala"}),
-            ('html_file', {'input': "gedit.html"}),
-            ]
-    
+        ('single_char', {'input': "a"}),
+        ('short_name', {'input': "test"}),
+        ('long_name', {'input': "testfilenameforgedit"}),
+        ('extra_long_name', {'input': "autopilotlongfilenamefortesting"}),
+        ('python_file', {'input': "gedit.py"}),
+        ('C_file', {'input': "gedit.c"}),
+        ('cpp_file', {'input': "gedit.cpp"}),
+        ('xml_file', {'input': "gedit.xml"}),
+        ('vala_file', {'input': "gedit.vala"}),
+        ('html_file', {'input': "gedit.html"}),
+    ]
+
     def test_save_file_type_tests(self, ):
-        #setup test with empty doc and save dialog opened
+        # setup test with empty doc and save dialog opened
         self.setup_test_docs(1, save_dlg=True)
         save_dlg = self.app.select_single('GeditFileChooserDialog')
         self.pointing_device.move_to_object(
             save_dlg.select_single('GtkLabel',
                                    label='_Cancel'))
-        #for each scenario enter filename
+        # for each scenario enter filename
         self.keyboard.type(self.input)
-        #click save
-        
+        # click save
+
         self.pointing_device.click_object(
             save_dlg.select_single('GtkLabel', label='_Save'))
-        #check dialog closed before checking for file
+        # check dialog closed before checking for file
         self.assertThat(lambda: self.app.select_many('GeditTab')[0].name,
                         Eventually(Equals(self.input)),
-                        "Tab did not contain filename "+self.input)
+                        "Tab did not contain filename " + self.input)
         filename = self.input
-        
-        self.assertThat('/tmp/'+filename, FileExists())
-        #add cleanup
+
+        self.assertThat('/tmp/' + filename, FileExists())
+        # add cleanup
         self.addCleanup(os.remove, '/tmp/%s' % self.input)
-        
-        
+
+
 class GeditSaveDialogTests(GeditAutopilotTestCase):
-    
+
     def test_esc_key_closes_dialog(self, ):
         self.setup_test_docs(1, save_dlg=True)
         self.keyboard.press_and_release('Escape')
@@ -482,9 +530,9 @@
                                "'NoneType' object has no attribute 'visible'"):
             self.assertThat(lambda: self.app.select_single(
                 'GeditFileChooserDialog').visible,
-                            Eventually(Equals(0)),
-                            "Dialog didn't close")
-            
+                Eventually(Equals(0)),
+                "Dialog didn't close")
+
     def test_cancel_button_closes_dialog(self, ):
         self.setup_test_docs(1, save_dlg=True)
         save_dialog = self.app.select_single('GeditFileChooserDialog')
@@ -496,9 +544,9 @@
                                "'NoneType' object has no attribute 'visible'"):
             self.assertThat(lambda: self.app.select_single(
                 'GeditFileChooserDialog').visible,
-                            Eventually(Equals(0)),
-                            "Dialog didn't close")
-        
+                Eventually(Equals(0)),
+                "Dialog didn't close")
+
     def test_new_folder_button(self, ):
         self.setup_test_docs(1, save_dlg=True)
         save_dialog = self.app.select_single('GeditFileChooserDialog')
@@ -509,6 +557,7 @@
         self.assertThat('/tmp/test_folder', DirExists())
         self.addCleanup(os.rmdir, '/tmp/test_folder')
 
+
 class GeditOpenFileTypesTests(GeditAutopilotTestCase):
     scenarios = [
         ('test_file', {'input': "test"}),
@@ -518,7 +567,7 @@
         ('vala_file', {'input': "gedit.vala"}),
         ('xml_file', {'input': "gedit.xml"}),
     ]
-    
+
     def test_open_file_type_tests(self, ):
         self.setup_test_docs(1, opn_dlg=True)
         self.keyboard.type(self.input)
@@ -527,29 +576,31 @@
                                                                label='_Open'))
         self.assertThat(lambda: self.app.select_single('GeditWindow').title,
                         Eventually(Contains(self.input)))
-        
-        
+
+
 class GeditOpenDialogTests(GeditAutopilotTestCase):
-    
+
     def test_esc_key_closes_dialog(self, ):
         self.pointing_device.click_object(
             self.app.select_single('GeditOpenToolButton'))
-        self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                        Eventually(Equals(1)), "file chooser dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditFileChooserDialog').visible,
+            Eventually(Equals(1)), "file chooser dialog did not open")
         self.keyboard.press_and_release('Escape')
         # The fact we can't select dialog shows it closed
         with ExpectedException(AttributeError,
                                "'NoneType' object has no attribute 'visible'"):
             self.assertThat(lambda: self.app.select_single(
                 'GeditFileChooserDialog').visible,
-                            Eventually(Equals(0)),
-                            "Dialog didn't close")
-    
+                Eventually(Equals(0)),
+                "Dialog didn't close")
+
     def test_cancel_button_closes_dialog(self, ):
         self.pointing_device.click_object(
             self.app.select_single('GeditOpenToolButton'))
-        self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                        Eventually(Equals(1)), "file chooser dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditFileChooserDialog').visible,
+            Eventually(Equals(1)), "file chooser dialog did not open")
         open_dialog = self.app.select_single('GeditFileChooserDialog')
         self.pointing_device.click_object(
             open_dialog.select_single('GtkLabel',
@@ -559,19 +610,20 @@
                                "'NoneType' object has no attribute 'visible'"):
             self.assertThat(lambda: self.app.select_single(
                 'GeditFileChooserDialog').visible,
-                            Eventually(Equals(0)),
-                            "Dialog didn't close")
-    
+                Eventually(Equals(0)),
+                "Dialog didn't close")
+
     def test_recent_docs_displayed_on_load(self, ):
         self.pointing_device.click_object(
             self.app.select_single('GeditOpenToolButton'))
-        self.assertThat(lambda: self.app.select_single('GeditFileChooserDialog').visible,
-                        Eventually(Equals(1)), "file chooser dialog did not open")
+        self.assertThat(
+            lambda: self.app.select_single('GeditFileChooserDialog').visible,
+            Eventually(Equals(1)), "file chooser dialog did not open")
         open_dialog = self.app.select_single('GeditFileChooserDialog')
-        self.assertThat(lambda: open_dialog.select_single('GtkLabel',
-                                                          label='<b>Recently Used</b>').visible,
-                        Eventually(Equals(1)), "Recently used not visible")
-    
+        self.assertThat(lambda: open_dialog.select_single(
+            'GtkLabel', label='<b>Recently Used</b>').visible,
+            Eventually(Equals(1)), "Recently used not visible")
+
 
 class GeditReplaceDialogTests(GeditAutopilotTestCase):
 
@@ -583,78 +635,93 @@
         self.keyboard.type('foxes')
         self.assertTrue(self.replace_entry_text.text, Equals('foxes'))
         self.pointing_device.click_object(self.find_button)
-        #lets check replace button is now clickable
+        # lets check replace button is now clickable
         self.assertThat(self.replace_button.sensitive, Eventually(Equals(1)))
         self.pointing_device.click_object(self.replace_button)
-        #test text was replaced
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(Equals('Document 1: The quick brown foxes jumps over the lazy dog')))
-    
+        # test text was replaced
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(Equals(
+                'Document 1: The quick brown foxes jumps over the lazy dog')))
+
     def test_match_case_option(self, ):
         # test doesnt match
         self.setup_test_docs(1, text=True, replace_dlg=True)
         self.keyboard.type('Fox')
         self.assertTrue(self.search_entry_text.text, Equals('Fox'))
         self.pointing_device.click_object(self.mtch_chkbtn)
-        #check its selected
+        # check its selected
         self.assertTrue(self.mtch_chkbtn.active, Equals(1))
         self.pointing_device.click_object(self.replace_all_button)
-        #FIXME:
-        #the replace button should stay inactive as it doesn't match case
-        #for some reason it says the sensitive property is 1 but in vis shows 0
-        #self.assertThat(self.replace_button.sensitive, Equals(0))
-        #instead click replace all and check fox was not replaced in the buffer
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(Equals('Document 1: The quick brown fox jumps over the lazy dog')))
-        #test does match
+        # FIXME:
+        # the replace button should stay inactive as it doesn't match entire
+        # word for some reason it says the sensitive property is 1 but in vis
+        # shows 0
+        # self.pointing_device.click_object(self.find_button)
+        # self.assertThat(self.replace_button.sensitive, Equals(0))
+        # instead click replace all and check fox was not replaced in the
+        # buffer
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(Equals(
+                'Document 1: The quick brown fox jumps over the lazy dog')))
+        # test does match
         self.pointing_device.click_object(self.search_entry)
         self.keyboard.press_and_release('Ctrl+a')
         self.keyboard.type('fox')
         self.pointing_device.click_object(self.replace_all_button)
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(Equals('Document 1: The quick brown  jumps over the lazy dog')))
-        
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(Equals(
+                'Document 1: The quick brown  jumps over the lazy dog')))
+
     def test_match_entire_word_option(self, ):
         self.setup_test_docs(1, text=True, replace_dlg=True)
         self.keyboard.type('fo')
         self.assertTrue(self.search_entry_text.text, Equals('fo'))
         self.pointing_device.click_object(self.entire_chkbtn)
-        #check its selected
+        # check its selected
         self.assertTrue(self.entire_chkbtn.active, Equals(1))
-        #FIXME:
-        #the replace button should stay inactive as it doesn't match entire word
-        #for some reason it says the sensitive property is 1 but in vis shows 0
-        #self.pointing_device.click_object(self.find_button)
-        #self.assertThat(self.replace_button.sensitive, Equals(0))
-        #instead click replace all and check fox was not replaced in the buffer
+        # FIXME:
+        # the replace button should stay inactive as it doesn't match entire
+        # word for some reason it says the sensitive property is 1 but in vis
+        # shows 0
+        # self.pointing_device.click_object(self.find_button)
+        # self.assertThat(self.replace_button.sensitive, Equals(0))
+        # instead click replace all and check fox was not replaced in the
+        # buffer
         self.pointing_device.click_object(self.replace_all_button)
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(Equals('Document 1: The quick brown fox jumps over the lazy dog')))
-        #test does match
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(Equals(
+                'Document 1: The quick brown fox jumps over the lazy dog')))
+        # test does match
         self.pointing_device.click_object(self.search_entry)
         self.keyboard.press_and_release('Ctrl+a')
         self.keyboard.type('fox')
         self.pointing_device.click_object(self.replace_all_button)
-        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
-                        Eventually(Equals('Document 1: The quick brown  jumps over the lazy dog')))
-    
+        self.assertThat(
+            lambda: self.app.select_many('GeditView')[0].buffer,
+            Eventually(Equals(
+                'Document 1: The quick brown  jumps over the lazy dog')))
+
     def test_esc_key_closes_dialog(self, ):
         self.setup_test_docs(1, replace_dlg=True)
         self.keyboard.press_and_release('Escape')
         self.assertThat(lambda: self.app.select_single(
             'GeditReplaceDialog').visible,
-                        Eventually(Equals(0)),"Dialog didn't close")
-    
+            Eventually(Equals(0)), "Dialog didn't close")
+
     def test_close_button_closes_dialog(self, ):
         self.setup_test_docs(1, replace_dlg=True)
         self.pointing_device.click_object(self.close_button)
         self.assertThat(lambda: self.app.select_single(
             'GeditReplaceDialog').visible,
-                        Eventually(Equals(0)),"Dialog didn't close")
-    
+            Eventually(Equals(0)), "Dialog didn't close")
+
 
 class GeditSingleFileCommandLineTest(AutopilotTestCase):
-    
+
     def setUp(self):
         super(GeditSingleFileCommandLineTest, self).setUp()
         sample_file = 'test'
@@ -663,15 +730,15 @@
                 if name == sample_file:
                     file_path = os.path.abspath(os.path.join(root, name))
         self.gedit = self.launch_test_application("gedit", file_path)
-        
-    #can we open files in gedit from terminal
+
+    # can we open files in gedit from terminal
     def test_open_single_file(self, ):
         self.assertThat(lambda: self.gedit.select_single('GeditWindow').title,
                         Eventually(Contains('test')))
 
 
 class GeditMultiFileCommandLineTest(AutopilotTestCase):
-    
+
     def setUp(self):
         super(GeditMultiFileCommandLineTest, self).setUp()
         sample_dir = 'samples'
@@ -680,45 +747,48 @@
                 if name == sample_dir:
                     file_path = os.path.abspath(os.path.join(root, name))
         self.gedit = self.launch_test_application("gedit",
-                                                  file_path+'/test',
-                                                  file_path+'/gedit.py',
-                                                  file_path+'/gedit.c',
-                                                  file_path+'/gedit.vala')
-        
+                                                  file_path + '/test',
+                                                  file_path + '/gedit.py',
+                                                  file_path + '/gedit.c',
+                                                  file_path + '/gedit.vala')
+
     def test_open_multi_files(self, ):
-        
-        #the first opened doc 'tab 1' should be in the title
+
+        # the first opened doc 'tab 1' should be in the title
         self.assertThat(lambda: self.gedit.select_single('GeditWindow').title,
                         Eventually(Contains('test')))
-        #check 4 tabs are there
+        # check 4 tabs are there
         self.assertThat(len(self.gedit.select_many('GeditTab')), Equals(4))
-        #TODO: test the contents of the files are diplayed
+        # TODO: test the contents of the files are diplayed
         # but is this needed? as tab title is covered by
         # another test and so is file contents displayed
 
+
 class GeditCommandLineTests(AutopilotTestCase):
-    
+
     def setUp(self):
         super(GeditCommandLineTests, self).setUp()
         self.app = self.launch_test_application("gedit")
-        
-    
+
     def test_new_doc_arg(self, ):
-        #check window open with one tab
+        # check window open with one tab
         self.assertThat(lambda: self.app.select_single('GeditWindow').visible,
                         Eventually(Equals(1)))
         self.assertThat(len(self.app.select_many('GeditTab')), Equals(1))
-        #now lets use the --new-document argument and we should get another tab
+        # now lets use the --new-document argument and we should get another
+        # tab
         subprocess.check_call(["gedit", "--new-document"])
-        self.assertThat(lambda: self.app.select_many('GeditTab')[1].visible, Eventually(Equals(1)))
+        self.assertThat(lambda: self.app.select_many(
+            'GeditTab')[1].visible, Eventually(Equals(1)))
 
     def test_new_window_arg(self, ):
         self.assertThat(lambda: self.app.select_single('GeditWindow').visible,
                         Eventually(Equals(1)))
-        #now lets use the --new-window argument and we should get another window
+        # now lets use the --new-window argument and we should get another
+        # window
 
         subprocess.check_call(["gedit", "--new-window"])
         self.assertThat(lambda: self.app.select_many('GeditWindow')[1].visible,
                         Eventually(Equals(1)))
-        #lets just confirm we have 2 windows
+        # lets just confirm we have 2 windows
         self.assertThat(len(self.app.select_many('GeditWindow')), Equals(2))

=== modified file 'ubuntu_autopilot_tests/nautilus/test_nautilus.py'
--- ubuntu_autopilot_tests/nautilus/test_nautilus.py	2013-05-27 11:24:25 +0000
+++ ubuntu_autopilot_tests/nautilus/test_nautilus.py	2013-11-23 00:24:47 +0000
@@ -6,10 +6,13 @@
 import os
 from time import sleep
 
-#Register Nautilus as an application so we can call it
-ProcessManager.register_known_application("File Browser", "nautilus.desktop", "nautilus")
-
-#http://packages.qa.ubuntu.com/qatracker/testcases/1424/info
+# Register Nautilus as an application so we can call it
+ProcessManager.register_known_application(
+    "File Browser", "nautilus.desktop", "nautilus")
+
+# http://packages.qa.ubuntu.com/qatracker/testcases/1424/info
+
+
 class NautilusTests(AutopilotTestCase):
 
     def setUp(self):
@@ -17,37 +20,38 @@
         self.proc_manager = ProcessManager.create('BAMF')
         self.app = self.proc_manager.start_app_window("File Browser")
 
-        #This will make sure nautilus window you launched is focused and ready to accept your keyboard input
+        # This will make sure nautilus window you launched is focused and ready
+        # to accept your keyboard input
         self.app.set_focus()
-        #We need to assert the window title = Home here to keep focus of nautilus. #
-        #It fails with assertTrue(self.app.is_focused)
+        # We must assert the window title = Home here to keep focus of nautilus
+        # It fails with assertTrue(self.app.is_focused)
         self.assertThat(lambda: self.app.title, Eventually(Contains('Home')))
 
-
     def test_create_a_folder(self):
-        #Test-case name: nautilus/TC-NFM-002
-        #This test will check that user can create folders in Nautilus
+        # Test-case name: nautilus/TC-NFM-002
+        # This test will check that user can create folders in Nautilus
 
-        #Select tmp folder
+        # Select tmp folder
         self.keyboard.press_and_release("Ctrl+l")
         self.keyboard.type('/tmp/')
         self.keyboard.press_and_release('Enter')
-        #make new folder
-        tempName=_generateTempFileName()
+        # make new folder
+        tempName = _generateTempFileName()
         (dirName, fileName) = os.path.split(tempName)
         self.keyboard.press_and_release("Ctrl+Shift+n")
-        #use the generated filename as folder name in this case
+        # use the generated filename as folder name in this case
         self.keyboard.type(fileName)
         self.keyboard.press_and_release('Enter')
         self.keyboard.press_and_release('Enter')
-        #verify folder
+        # verify folder
         self.assertThat(lambda: self.app.title, Eventually(Contains(fileName)))
 
-        #delete folder
+        # delete folder
         self.addCleanup(os.rmdir, tempName)
 
+
 def _generateTempFileName():
-    #Create temporary file, then close it, so we can re-use the file name
+    # Create temporary file, then close it, so we can re-use the file name
     sFile = tempfile.NamedTemporaryFile()
     sFile.close()
     return sFile.name

=== modified file 'ubuntu_autopilot_tests/screenshot/test_screenshot.py'
--- ubuntu_autopilot_tests/screenshot/test_screenshot.py	2013-06-07 19:03:36 +0000
+++ ubuntu_autopilot_tests/screenshot/test_screenshot.py	2013-11-23 00:24:47 +0000
@@ -9,7 +9,9 @@
 import os
 import shutil
 
-#http://packages.qa.ubuntu.com/qatracker/testcases/1421/info
+# http://packages.qa.ubuntu.com/qatracker/testcases/1421/info
+
+
 class ScreenshotTests(AutopilotTestCase):
 
     def setUp(self):
@@ -20,160 +22,192 @@
         self.pointing_device = Pointer(Mouse.create())
         self.archiveWindow = self.app.select_single('GtkDialog')
 
-        #verify window title: Take Screenshot to verify Screenshot is correclty opened
-        self.assertThat(self.archiveWindow.title, Eventually(Contains('Take Screenshot')))
-        
-        self.take_screenshot_button = self.app.select_single('GtkLabel', label='Take _Screenshot')
-        self.grab_whole_screen_rb = self.app.select_single('GtkRadioButton', label='Grab the whole sc_reen')
-        self.grab_curr_window_rb = self.app.select_single('GtkRadioButton', label='Grab the current _window')
-        self.select_grab_area_rb=self.app.select_single('GtkRadioButton', label='Select _area to grab')
-        self.incl_win_border=self.app.select_single('GtkCheckButton', label='Include the window _border')
-##        self.drop_shadow_effect_shadow=self.app.select_single('GtkComboBoxAccessible', accessible_name='shadow')
-##        self.drop_shadow_effect_none=self.app.select_single('GtkComboBoxAccessible', accessible_name='none')
-##        self.drop_shadow_effect_border=self.app.select_single('GtkComboBoxAccessible', accessible_name='border')
-    
-        #potentially useful objects
-        #self.border_effect=self.app.select_single('GtkComboBoxAccessible', accessible_name='border')
-        #self.no_effect=self.app.select_single('GtkComboBoxAccessible', accessible_name='none')
-        #self.app.select_single('GtkLabel', label='Grab after a _delay of')
-        #self.app.select_single('GtkCheckButton', label='Include _pointer')
-        #self.app.select_single('GtkToggleButtonAccessible', accessible_name='Include pointer')
-        #self.app.select_single('GtkToggleButtonAccessible', accessible_name='Include the window border')
-        #self.app.select_single('GtkMenuItemAccessible', accessible_name='Drop shadow')
-        #self.app.select_single('GtkLabel', label='Apply _effect:')
-        #self.app.select_single('GtkLabelAccessible', accessible_name='Apply effect:')        
-        
+        # verify window title: Take Screenshot to verify Screenshot is
+        # correclty opened
+        self.assertThat(self.archiveWindow.title,
+                        Eventually(Contains('Take Screenshot')))
+
+        self.take_screenshot_button = self.app.select_single(
+            'GtkLabel', label='Take _Screenshot')
+        self.grab_whole_screen_rb = self.app.select_single(
+            'GtkRadioButton', label='Grab the whole sc_reen')
+        self.grab_curr_window_rb = self.app.select_single(
+            'GtkRadioButton', label='Grab the current _window')
+        self.select_grab_area_rb = self.app.select_single(
+            'GtkRadioButton', label='Select _area to grab')
+        self.incl_win_border = self.app.select_single(
+            'GtkCheckButton', label='Include the window _border')
+# self.drop_shadow_effect_shadow=self.app.select_single(
+#     'GtkComboBoxAccessible', accessible_name='shadow')
+# self.drop_shadow_effect_none=self.app.select_single(
+#     'GtkComboBoxAccessible', accessible_name='none')
+# self.drop_shadow_effect_border=self.app.select_single(
+#     'GtkComboBoxAccessible', accessible_name='border')
+
+        # potentially useful objects
+        # self.border_effect=self.app.select_single('GtkComboBoxAccessible',
+        #                                           accessible_name='border')
+        # self.no_effect=self.app.select_single('GtkComboBoxAccessible',
+        #                                       accessible_name='none')
+        # self.app.select_single('GtkLabel', label='Grab after a _delay of')
+        # self.app.select_single('GtkCheckButton', label='Include _pointer')
+        # self.app.select_single('GtkToggleButtonAccessible',
+        #                        accessible_name='Include pointer')
+        # self.app.select_single('GtkToggleButtonAccessible',
+        #                        accessible_name='Include the window border')
+        # self.app.select_single('GtkMenuItemAccessible',
+        #                        accessible_name='Drop shadow')
+        # self.app.select_single('GtkLabel', label='Apply _effect:')
+        # self.app.select_single('GtkLabelAccessible', accessible_name='Apply
+        # effect:')
+
     def test_whole_screen(self):
-        #Test-case name: gnomescreenshot/gns-001
-        #This test will check that Gnome Screenshot can save screenshot of the whole screen
+        # Test-case name: gnomescreenshot/gns-001
+        # This test will check that Gnome Screenshot can save screenshot of the
+        # whole screen
 
-        #Grab the whole desktop
-        #Select Grab Whole Screen radio button and click on it
+        # Grab the whole desktop
+        # Select Grab Whole Screen radio button and click on it
         self.pointing_device.move_to_object(self.grab_whole_screen_rb)
         self.pointing_device.click()
 
-        #Select Take screenshot button and click it
+        # Select Take screenshot button and click it
         self.click_take_screenshot()
 
-        #verify take screenshot window opens
+        # verify take screenshot window opens
         tempArchive = _tempArchiveName()
         (dirName, fileName) = os.path.split(tempArchive)
         self.save_screenshot_file(fileName)
 
-        #Is the screenshot image saved to the /tmp directory? Is it a valid image file containing your screen?
-        #verify it's a non-zero file
+        # Is the screenshot image saved to the /tmp directory?
+        # Is it a valid image file containing your screen?
+        # verify it's a non-zero file
         self.verify_non_zero_file(fileName)
-        
-        #Cleanup
+
+        # Cleanup
         self.delete_temp_file(tempArchive)
 
     def test_selected_window(self):
-        #Test-case name: gnomescreenshot/gns-002
-        #This test will check that Gnome Screenshot can save screenshot of selected window
+        # Test-case name: gnomescreenshot/gns-002
+        # This test will check that Gnome Screenshot can save screenshot of
+        # selected window
 
-        #Select Grab the current window
+        # Select Grab the current window
         self.pointing_device.move_to_object(self.grab_curr_window_rb)
         self.pointing_device.click()
-        #Select Take screenshot button and click it
+        # Select Take screenshot button and click it
         self.click_take_screenshot()
 
-        #verify take screenshot window opens
+        # verify take screenshot window opens
         tempArchive = _tempArchiveName()
         (dirName, fileName) = os.path.split(tempArchive)
         self.save_screenshot_file(fileName)
 
-        #Is the screenshot image saved to the /tmp directory? Is it a valid image file containing your screen?
-        #verify it's a non-zero file
+        # Is the screenshot image saved to the /tmp directory?
+        # Is it a valid image file containing your screen?
+        # verify it's a non-zero file
         self.verify_non_zero_file(fileName)
-        
-        #Cleanup
+
+        # Cleanup
         self.delete_temp_file(tempArchive)
 
     def test_drop_shadow_effect(self):
-        #Test-case name: gnomescreenshot/gns-003
-        #This test will check that Gnome Screenshot can save screenshot of selected window
-        
-        #Select Grab the current window
+        # Test-case name: gnomescreenshot/gns-003
+        # This test will check that Gnome Screenshot can save screenshot of
+        # selected window
+
+        # Select Grab the current window
         self.pointing_device.move_to_object(self.grab_curr_window_rb)
         self.pointing_device.click()
-        
-        #Verify the "Include the window border" box is selected
+
+        # Verify the "Include the window border" box is selected
         if self.incl_win_border.active == 0:
             self.pointing_device.move_to_object(self.incl_win_border)
             self.pointing_device.click()
-        self.assertThat(lambda: self.incl_win_border.active, Eventually(Equals(1)))
-
-##        #Select Drop shadow from the Apply effect drop down menu
-##        if self.drop_shadow_effect_none.enabled == 'True':
-##           self.pointing_device.move_to_object(self.drop_shadow_effect_none)
-##        elif self.drop_shadow_effect_shadow.enabled == 'True':
-##           self.pointing_device.move_to_object(self.drop_shadow_effect_shadow)    
-##        else:
-##           self.pointing_device.move_to_object(self.drop_shadow_effect_border)
-##        self.pointing_device.click()
-##        self.keyboard.press_and_release('Down')
-##        self.keyboard.type('\n')
-##        self.pointing_device.click()
-##        self.pointing_device.click()
-        
-##       #Verify the "Drop shadow"  is selected
-###       don't use these assertions
-###        self.assertThat(lambda: self.drop_shadow_effect.selected, Eventually(Equals(True)))
-###        self.assertThat(lambda: self.drop_shadow_effect.focused, Eventually(Equals(True)))
-##        self.assertThat(lambda: self.drop_shadow_effect.enabled, Eventually(Equals(True)))
-    
-        #Select Take screenshot button and click it
+        self.assertThat(
+            lambda: self.incl_win_border.active, Eventually(Equals(1)))
+
+# Select Drop shadow from the Apply effect drop down menu
+# if self.drop_shadow_effect_none.enabled == 'True':
+# self.pointing_device.move_to_object(self.drop_shadow_effect_none)
+# elif self.drop_shadow_effect_shadow.enabled == 'True':
+# self.pointing_device.move_to_object(self.drop_shadow_effect_shadow)
+# else:
+# self.pointing_device.move_to_object(self.drop_shadow_effect_border)
+# self.pointing_device.click()
+# self.keyboard.press_and_release('Down')
+# self.keyboard.type('\n')
+# self.pointing_device.click()
+# self.pointing_device.click()
+
+# Verify the "Drop shadow"  is selected
+# don't use these assertions
+# self.assertThat(lambda: self.drop_shadow_effect.selected,
+#                 Eventually(Equals(True)))
+# self.assertThat(lambda: self.drop_shadow_effect.focused,
+#                 Eventually(Equals(True)))
+# self.assertThat(lambda: self.drop_shadow_effect.enabled,
+# Eventually(Equals(True)))
+
+        # Select Take screenshot button and click it
         self.click_take_screenshot()
-            
-        #Make sure screenshot window you launched is focused and ready to accept your keyboard input
+
+        # Make sure screenshot window you launched is focused and ready to
+        # accept your keyboard input
         tempArchive = _tempArchiveName()
         (dirName, fileName) = os.path.split(tempArchive)
         self.save_screenshot_file(fileName)
 
-       #Is the screenshot image saved to the /tmp directory? Is it a valid image file containing your screen?
-        #verify it's a non-zero file
+        # Is the screenshot image saved to the /tmp directory?
+        # Is it a valid image file containing your screen?
+        # verify it's a non-zero file
         self.verify_non_zero_file(fileName)
 
-        #Cleanup
+        # Cleanup
         self.delete_temp_file(tempArchive)
 
     def save_screenshot_file(self, fileName):
-        check_fn = lambda: self.app.select_single('GtkDialog', title='Save Screenshot')
+        check_fn = lambda: self.app.select_single(
+            'GtkDialog', title='Save Screenshot')
         self.assertThat(check_fn, Eventually(NotEquals(None)))
-        #select everything so to cancel old file name
+        # select everything so to cancel old file name
         self.keyboard.press_and_release('Ctrl+a')
         self.keyboard.type(fileName)
         self.keyboard.type('.png')
-        #select /tmp folder
-        self.save_in_folder_button=self.app.select_single('GtkFileChooserButton', title='Select a folder')
+        # select /tmp folder
+        self.save_in_folder_button = self.app.select_single(
+            'GtkFileChooserButton', title='Select a folder')
         self.pointing_device.move_to_object(self.save_in_folder_button)
         self.pointing_device.click()
-        #get to "other"
+        # get to "other"
         self.keyboard.press_and_release('End')
-        #save in the tmp folder
+        # save in the tmp folder
         self.keyboard.type("\n/tmp\n")
-        #Save screenshot
-        self.save_button=self.app.select_single('GtkLabel', label='_Save')
+        # Save screenshot
+        self.save_button = self.app.select_single('GtkLabel', label='_Save')
         self.pointing_device.move_to_object(self.save_button)
         self.pointing_device.click()
-        
-    def verify_non_zero_file(self,fileName):
-        self.assertThat(lambda: os.path.isfile('/tmp/'+fileName+'.png'), Eventually(Equals(True)))
-        self.assertThat(lambda: os.stat('/tmp/'+ fileName+'.png').st_size, Eventually(NotEquals(0)))
+
+    def verify_non_zero_file(self, fileName):
+        self.assertThat(lambda: os.path.isfile(
+            '/tmp/' + fileName + '.png'), Eventually(Equals(True)))
+        self.assertThat(
+            lambda: os.stat('/tmp/' + fileName + '.png').st_size,
+            Eventually(NotEquals(0)))
 
     def delete_temp_file(self, tempArchive):
-        #Delete the screenshot file
-        self.addCleanup(os.unlink, tempArchive+'.png')
+        # Delete the screenshot file
+        self.addCleanup(os.unlink, tempArchive + '.png')
 
     def click_take_screenshot(self):
-        #click on take screenshot button
+        # click on take screenshot button
         self.pointing_device.move_to_object(self.take_screenshot_button)
-        self.pointing_device.click()        
-
-
-#Create temporary file name
+        self.pointing_device.click()
+
+
+# Create temporary file name
 def _tempArchiveName():
     '''Temporary archive name.'''
     sFile = tempfile.NamedTemporaryFile()
     sFile.close()
-    return sFile.name
\ No newline at end of file
+    return sFile.name

=== modified file 'ubuntu_autopilot_tests/shotwell/test_shotwell.py'
--- ubuntu_autopilot_tests/shotwell/test_shotwell.py	2013-03-04 21:53:25 +0000
+++ ubuntu_autopilot_tests/shotwell/test_shotwell.py	2013-11-23 00:24:47 +0000
@@ -1,85 +1,92 @@
 from autopilot.testcase import AutopilotTestCase
 from autopilot.introspection.gtk import GtkIntrospectionTestMixin
 from autopilot.matchers import Eventually
-from testtools.matchers import Equals, NotEquals, GreaterThan, LessThan, Contains
+from testtools.matchers import Equals, NotEquals, \
+    GreaterThan, LessThan, Contains
 
 from time import sleep
 import tempfile
 import os
 
-#Register Shotwell as an application so we can call it
-AutopilotTestCase.register_known_application("Shotwell", "shotwell.desktop", "shotwell")
-
-#http://packages.qa.ubuntu.com/qatracker/testcases/1428/info
+# Register Shotwell as an application so we can call it
+AutopilotTestCase.register_known_application(
+    "Shotwell", "shotwell.desktop", "shotwell")
+
+# http://packages.qa.ubuntu.com/qatracker/testcases/1428/info
+
 
 class GtkToolbarTests(AutopilotTestCase, GtkIntrospectionTestMixin):
-     
+
     def setUp(self):
-        #Open Shotwell
+        # Open Shotwell
         super(GtkToolbarTests, self).setUp()
         self.app = self.launch_test_application('shotwell')
 
     def test_import_pictures(self):
-        #Test-case name: shotwell/swp-001
-        #This test will check that Shotwell can import pictures from camera
-        
-       # Plug in your camera using a USB cable. Your camera may need to be switched on, check the camera manual
+        # Test-case name: shotwell/swp-001
+        # This test will check that Shotwell can import pictures from camera
+
+       # Plug in your camera using a USB cable. Your camera may need to be
+       # switched on, check the camera manual
         _pluginCamera()
-        sleep(15)        
-        
-        #Select 'shotwell' in the dropdown and click ok
-        
-        #TODO this does not work as the window is not always focused
-        #if  I can focus the window then I can close it
-        #self.keyboard.press_and_release("Alt+o")
-                
-        #Verify that Shotwell is open   
-        #LibraryWindow
+        sleep(15)
+
+        # Select 'shotwell' in the dropdown and click ok
+
+        # TODO this does not work as the window is not always focused
+        # if  I can focus the window then I can close it
+        # self.keyboard.press_and_release("Alt+o")
+
+        # Verify that Shotwell is open
+        # LibraryWindow
         windowTitle = self.app.select_single('LibraryWindow', title='Shotwell')
         self.assertThat(windowTitle.title, Eventually(Equals('Shotwell')))
-        
-        #Shotwell loads and displays thumbnails of the photos on your camera   
-        #LibraryWindow, GtkBox, GtkPaned, GtkFrame, GtkAlignment, BasicProperties
+
+        # Shotwell loads and displays thumbnails of the photos on your camera
+        # LibraryWindow, GtkBox, GtkPaned, GtkFrame, GtkAlignment,
+        # BasicProperties
         rowsCols = self.app.select_single('BasicProperties')
         self.assertThat(rowsCols.n_rows, Eventually(GreaterThan(1)))
         self.assertThat(rowsCols.n_columns, Eventually(GreaterThan(1)))
 
-       # Select a single photo and click Import Selected (to make it simple I import all the photos)
-        #self.keyboard.press_and_release("Alt+f")
-        #sleep(1)
-        #self.keyboard.press_and_release("a")
-        #sleep(1)
-        #self.keyboard.type("\n")
-        #sleep(5)
-        
-        #Library, GtkBox, GtkPaned, GtkFrame, Gtkbox, GtkToolbar, GtkToolButton
+       # Select a single photo and click Import Selected
+       # (to make it simple I import all the photos)
+        # self.keyboard.press_and_release("Alt+f")
+        # sleep(1)
+        # self.keyboard.press_and_release("a")
+        # sleep(1)
+        # self.keyboard.type("\n")
+        # sleep(5)
+
+        # Library, GtkBox, GtkPaned, GtkFrame, Gtkbox, GtkToolbar,
+        # GtkToolButton
         btn = self.app.select_single('GtkToolButton', label='Import_All')
-        #does it exist?
+        # does it exist?
         self.assertThat(btn, NotEquals(None))
-        #let's click it
+        # let's click it
         self.mouse.move_to_object(btn)
         self.mouse.click()
-    
-       #Shotwell imports the photo and displays a prompt asking you if you wish to delete the photos from the camera    
-       #Select no.
+
+       # Shotwell imports the photo and displays a prompt asking you if you
+       # wish to delete the photos from the camera
+       # Select no.
        # press Alt+k to keep photos on camera
         self.keyboard.press_and_release("Alt+k")
- 
-        #Select 'last import' in the left hand pane
-        
-          
-        #Close Shotwell and exit    
+
+        # Select 'last import' in the left hand pane
+
+        # Close Shotwell and exit
         _closeAndExit()
         sleep(5)
 
 
 def _pluginCamera():
         # display message to warn tester to plugin an switch on camera
-        os.system("zenity --info --text 'Close this window, plug in and switch on your camera '")
-        
+    os.system(
+        "zenity --info --text 'Close this window, \
+        plug in and switch on your camera '")
 
 
 def _closeAndExit():
-     #Close open window gvfs-udisks2-volume-monitor
-     os.system("zenity --info --text 'Swtich off camera '")
-
+    # Close open window gvfs-udisks2-volume-monitor
+    os.system("zenity --info --text 'Swtich off camera '")

=== modified file 'ubuntu_autopilot_tests/terminal/__init__.py'
--- ubuntu_autopilot_tests/terminal/__init__.py	2013-08-02 10:04:08 +0000
+++ ubuntu_autopilot_tests/terminal/__init__.py	2013-11-23 00:24:47 +0000
@@ -29,9 +29,10 @@
 
     def setUp(self):
         super(TerminalAutopilotTestCase, self).setUp()
-        #print(HOME_DIR)
+        # print(HOME_DIR)
         self.app = self.launch_test_application('gnome-terminal',
-                                                '--working-directory=' + HOME_DIR,
+                                                '--working-directory=' +
+                                                HOME_DIR,
                                                 '--disable-factory'
                                                 )
 

=== modified file 'ubuntu_autopilot_tests/terminal/test_terminal.py'
--- ubuntu_autopilot_tests/terminal/test_terminal.py	2013-07-30 17:29:08 +0000
+++ ubuntu_autopilot_tests/terminal/test_terminal.py	2013-11-23 00:24:47 +0000
@@ -19,7 +19,8 @@
 import shutil
 import tempfile
 from autopilot.matchers import Eventually
-from testtools.matchers import Equals, Contains, FileExists, DirExists, DirContains
+from testtools.matchers import Equals, Contains, FileExists, DirExists, \
+    DirContains
 from terminal import TerminalAutopilotTestCase
 
 
@@ -27,9 +28,9 @@
 
     def test_save_a_file(self):
         self.keyboard.type("touch /tmp/test-file\n")
-        #Verify that test-file has been created
+        # Verify that test-file has been created
         self.assertTrue('/tmp/testfile', FileExists())
-        #Delete the file we created
+        # Delete the file we created
         self.addCleanup(os.remove, "/tmp/test-file")
 
     def test_create_directory(self):
@@ -44,24 +45,25 @@
 
     def test_move_directory_with_files(self):
         self.create_temp_directory_with_temp_files()
-        #create directory to move to
+        # create directory to move to
         self.keyboard.type('mkdir /tmp/temp-dir2\n')
-        #move temp-dir to temp-dir2
+        # move temp-dir to temp-dir2
         self.keyboard.type('mv /tmp/temp-dir/ /tmp/temp-dir2/\n')
-        #assert dir moved
+        # assert dir moved
         self.assertTrue('/tmp/temp-dir2/temp-dir/', DirExists())
-        ##assert files moved
-        self.assertTrue('/tmp/temp-dir2/temp-dir/', DirContains(['a', 'b', 'c']))
+        # assert files moved
+        self.assertTrue(
+            '/tmp/temp-dir2/temp-dir/', DirContains(['a', 'b', 'c']))
 
         self.addCleanup(shutil.rmtree, '/tmp/temp-dir2')
 
     def test_copying_file(self):
         self.create_temp_directory_with_temp_files()
-        #create directory to move to
+        # create directory to move to
         self.keyboard.type('mkdir /tmp/temp-dir2\n')
-        #move file 'a' to temp-dir2
+        # move file 'a' to temp-dir2
         self.keyboard.type('cp /tmp/temp-dir/a /tmp/temp-dir2/\n')
-        ##assert file moved
+        # assert file moved
         self.assertTrue('/tmp/temp-dir2/temp-dir/', DirContains(['a']))
         self.addCleanup(shutil.rmtree, '/tmp/temp-dir')
         self.addCleanup(shutil.rmtree, '/tmp/temp-dir2')
@@ -81,12 +83,12 @@
         terminal_window = self.app.select_single('TerminalWindow')
         self.keyboard.type('cd\n')
         self.keyboard.type('cd Documents\n')
-        self.assertThat(terminal_window.title, Eventually(Contains('~/Documents')))
+        self.assertThat(
+            terminal_window.title, Eventually(Contains('~/Documents')))
 
     def test_open_new_tab(self, ):
-        #open a new tab
+        # open a new tab
         self.keyboard.press_and_release('Ctrl+Shift+t')
         # test number of tabs(containers) equals 2
         tabs = self.app.select_many('TerminalScreenContainer')
         self.assertThat(len(tabs), Equals(2))
-

=== modified file 'ubuntu_autopilot_tests/totem/test_totem.py'
--- ubuntu_autopilot_tests/totem/test_totem.py	2013-06-04 20:17:41 +0000
+++ ubuntu_autopilot_tests/totem/test_totem.py	2013-11-23 00:24:47 +0000
@@ -1,6 +1,7 @@
 from autopilot.testcase import AutopilotTestCase
 from autopilot.matchers import Eventually
-from testtools.matchers import Equals, NotEquals, GreaterThan, LessThan, Contains
+from testtools.matchers import Equals, NotEquals, GreaterThan, LessThan, \
+    Contains
 from autopilot.input import Mouse, Touch, Pointer
 
 from time import sleep
@@ -8,52 +9,54 @@
 import os
 
 
-
-#http://packages.qa.ubuntu.com/qatracker/testcases/1429/info
+# http://packages.qa.ubuntu.com/qatracker/testcases/1429/info
 class TotemTests(AutopilotTestCase):
 
     def setUp(self):
-        #Open Totem
+        # Open Totem
         super(TotemTests, self).setUp()
         self.app = self.launch_test_application('totem')
-        
-        
+
         self.windowTitle = self.app.select_single('GtkWindow', title='Videos')
         self.pointing_device = Pointer(Mouse.create())
-        
-        
+
     def test_play_and_pause_video(self):
         # check the window loaded
         self.assertThat(self.windowTitle.title, Eventually(Contains('Videos')))
         self.status_label = self.app.select_single('GtkLabel', label='Stopped')
-        
+
         # add content to playlist and auto starts
         self.setup_video()
-        ## TODO assert playing label
-        
-        self.assertThat(self.status_label.label, Eventually(Contains('Playing')))
+        # TODO assert playing label
+
+        self.assertThat(
+            self.status_label.label, Eventually(Contains('Playing')))
         # press pause button
-        ## currently not working
-        #self.pause_button = self.app.select_single('GtkButton', tooltip_text='Pause')
-        #self.pointing_device.move_to_object(self.pause_button)
-        #self.pointing_device.click()
+        # currently not working
+        # self.pause_button = self.app.select_single('GtkButton',
+        #                                            tooltip_text='Pause')
+        # self.pointing_device.move_to_object(self.pause_button)
+        # self.pointing_device.click()
         self.keyboard.press_and_release('Ctrl+Space')
-        
-        self.assertThat(self.status_label.label, Eventually(Contains('Paused')))
+
+        self.assertThat(
+            self.status_label.label, Eventually(Contains('Paused')))
         # check we can start it playing again
         self.keyboard.press_and_release('Ctrl+Space')
-        self.assertThat(self.status_label.label, Eventually(Contains('Playing')))
-        
+        self.assertThat(
+            self.status_label.label, Eventually(Contains('Playing')))
+
     def setup_video(self, ):
         ''' select and add content to the playlist '''
-        #get the sidebar button
-        self.sidebar_button = self.app.select_single('GtkToggleButton', label='S_idebar')
-        #make sure playlist window is displayed
+        # get the sidebar button
+        self.sidebar_button = self.app.select_single(
+            'GtkToggleButton', label='S_idebar')
+        # make sure playlist window is displayed
         self.keyboard.press_and_release('Alt+v')
         self.keyboard.press_and_release('Up')
         self.keyboard.press_and_release('Up')
         self.keyboard.press_and_release('Enter')
-        #check if sidebar is already open, if not then open it
+        # check if sidebar is already open, if not then open it
         sideIsActive = self.sidebar_button.active
         if sideIsActive == 0:
             self.pointing_device.move_to_object(self.sidebar_button)
@@ -61,24 +64,24 @@
             sideIsActive = self.sidebar_button.active
         # check it is open
         self.assertThat(sideIsActive, Equals(1))
-        
-        #select the + button
-        self.add_button = self.app.select_single('GtkToolButton', tooltip_text='Add...')
-        #click on + button
+
+        # select the + button
+        self.add_button = self.app.select_single(
+            'GtkToolButton', tooltip_text='Add...')
+        # click on + button
         self.pointing_device.move_to_object(self.add_button)
         self.pointing_device.click()
         # check the file chooser dialog loaded
-        self.file_chooser_dialog = self.app.select_single('GtkFileChooserDialog')
-        self.assertThat(self.file_chooser_dialog.title, Eventually(Contains('Select Movies or Playlists')))
+        self.file_chooser_dialog = self.app.select_single(
+            'GtkFileChooserDialog')
+        self.assertThat(self.file_chooser_dialog.title,
+                        Eventually(Contains('Select Movies or Playlists')))
         # enter content path
         self.keyboard.press_and_release('Alt+d')
-        self.keyboard.type('/usr/share/example-content/Ubuntu_Free_Culture_Showcase')
+        self.keyboard.type(
+            '/usr/share/example-content/Ubuntu_Free_Culture_Showcase')
         # add the directory to the playlist
-        self.add_dir_button = self.app.select_single('GtkLabel', label='Add Directory')
+        self.add_dir_button = self.app.select_single(
+            'GtkLabel', label='Add Directory')
         self.pointing_device.move_to_object(self.add_dir_button)
         self.pointing_device.click()
-        
-        
-    
-        
-        
\ No newline at end of file