Merge lp:~dpniel/ubuntu-autopilot-tests/gedit into lp:ubuntu-autopilot-tests

[Dan Chapman ]

I have implemented the requirements of the two bug reports but on firther inspection I have seen many flaws in this test. If you read through I have made comments about each test which i will file a bug for these changes to be made. If you can see anymore let me know and will file more bugs :-)

[Nicholas Skaggs (nskaggs)]

Ok, I would do a few things here. This testcase looks like we can really test the app so much more with the new introspection bits. Good stuff!

Things we should do before pushing this:

-- Let's try and remove the basic sleeps

1) Remove this by checking for a new tab -- #Why not just check there is eventually a new tab???????
I see this logic in the code that could work
        documents = self.app.select_many('GeditTab')
        #note index starts at 0
        self.assertThat(documents[orginalNumDocuments].name, Contains(str(orginalNumDocuments + 1)))

2) The sleep(3) occurences. They occur waiting for subwindows like open/save/close dialogs. Can we check properly for these to appear? If not, we should think carefully about pushing anyway, if we want this to go to prod.

-- Let's comment out completely the tests that have no asserts, or add a simple assert. Every test needs a assert or there's no reason to even run it.

Things still needing work for later:

-- We should stop using keyboard shortcuts for everything and convert to mouse movements where it makes sense. Click the save button, don't use alt+s, etc

-- We should finish out some of the stubbed testcases; anything we've commented out above, along with expanding the testcases using objects since we can access them now.

[Nicholas Skaggs (nskaggs)]

On this comment, can't we use an eventually looking at the recent docs label instead?

        #inserted sleep to see the recent files otherwise window closes too quicly
        sleep(2)

Let's just comment these out;
test_highlight_searched_text
test_shortcuts

I think you could uncomment this; even add to it easily
test_insert_overwrite_mode

Comment or implement;
test_tab_manipulation

This could be an easy assert fix; test_display_file_browser_panel

review: Needs Fixing

[Dan Chapman  (dpniel)]

I totally agree,

Looking through the test i can't see an area where sleeps will be required, so i will lose all of them as we can just wait on the visible property to change.

I will work on all those changes tomorrow and take it further as I can see areas that can now be tested. With whats available now to introspect we can definately make a very solid test for gedit.

I did file a bug for higlight test which is possible although we can't see the highlighted text we can introspect the search box and from there when entering a search query if you hit enter twice the word you queried dissapears and then test the textview buffer that it has gone. So as long as before the search we can assert the buffer text then assert the search query box entry was typed correctly and then assert that the word dissapears from the textview buffer we can safely say it highlighted it.

anyway i will re-work it and see how we go :-)

[Nicholas Skaggs (nskaggs)]

> I did file a bug for higlight test which is possible although we can't see the
> highlighted text we can introspect the search box and from there when entering
> a search query if you hit enter twice the word you queried dissapears and then
> test the textview buffer that it has gone. So as long as before the search we
> can assert the buffer text then assert the search query box entry was typed
> correctly and then assert that the word dissapears from the textview buffer we
> can safely say it highlighted it.

This is really clever! I can see this working!

[lp:~dpniel/ubuntu-autopilot-tests/gedit]

62. By Dan Chapman <email address hidden> on 2013-08-07

commit for some keyboard shortcut tests

63. By Dan Chapman <email address hidden> on 2013-08-07

removed the old tests

64. By Dan Chapman <email address hidden> on 2013-08-09

some more

65. By Dan Chapman <email address hidden> on 2013-08-09

hmmmm

66. By Dan Chapman <email address hidden> on 2013-08-11

some notes

67. By Dan Chapman <email address hidden> on 2013-08-12

Finished toolbar button tests

68. By Dan Chapman <email address hidden> on 2013-08-12

save diff file types

69. By Dan Chapman <email address hidden> on 2013-08-12

now saves file types of various different extensions

70. By Dan Chapman <email address hidden> on 2013-08-12

added some save dialog tests

71. By Dan Chapman <email address hidden> on 2013-08-12

created tests to open files in gedit from terminal

72. By Dan Chapman <email address hidden> on 2013-08-12

Tests to load files in gedit from terminal complete

73. By Dan Chapman <email address hidden> on 2013-08-12

added test for opening various different file types

74. By Dan Chapman <email address hidden> on 2013-08-13

open file type tests now passing
gedit.c file seemed to stop it working so
copied and renamed to gedit1.c

75. By Dan Chapman <email address hidden> on 2013-08-13

added tests for the open dialog

76. By Dan Chapman <email address hidden> on 2013-08-13

created tests for replace dialog

77. By Dan Chapman <email address hidden> on 2013-08-13

added some comments

78. By Dan Chapman <email address hidden> on 2013-08-13

mods

[Dan Chapman  (dpniel)]

Ok so now I have expanded this test quite significantly. Running 63 tests lasts like 15 mins atm :-O there is still plenty more tests to be written e.g print preview window and print dialog. We could also do some more save file tests but i think as it stands right now we can push this into production and get some meaningful test output.

[Dan Chapman  (dpniel)]

just looked further into the print dialog and it seems we can't see as much in that and it will require alot of walking the tree to find the right objects. so will take a while to do and not sure how we can test print preview with zoom etc as there seems to be no visual of zoom level, maybe we can see it in the properties though. There is already test for opening print preview so we know it opens. i will add ones for close using button and esc key and see from there.

[Nicholas Skaggs (nskaggs)]

Just repeating a bit of the IRC conversation. I'd like to see some focus asserts before typing text if possible, provided there exists such a property in the gedit object. In addition, I would move the command line tests to use a true command line call and skip using terminal. In addition, add --new-document and --new-window as tests.

Overall, this look great and is a new benchmark for gtk tests moving forward. Kudos Dan!

review: Needs Fixing

[lp:~dpniel/ubuntu-autopilot-tests/gedit]

79. By Dan Chapman <email address hidden> on 2013-08-13

added is_focus tests to all objects with the property available
also seperated Terminal tests to launch single and multi file
using raw cmd line and not use terminal

80. By Dan Chapman <email address hidden> on 2013-08-14

added tests for using --new-document and --new-window cmd line args

ready for review

[Dan Chapman  (dpniel)]

So i have used the is_focus property where ever possible when entering text. I have also seperated the command line tests to load documents not using the terminal. And finally 2 tests for --new-document and --new-window. If you can think of more let me know :-)

[Nicholas Skaggs (nskaggs)]

Not as many is focus as we could have hoped for. Still, excellent work, let's get this in prod

review: Approve

=== modified file 'ubuntu_autopilot_tests/gedit/__init__.py'
--- ubuntu_autopilot_tests/gedit/__init__.py	2012-12-28 14:02:50 +0000
+++ ubuntu_autopilot_tests/gedit/__init__.py	2013-08-14 17:04:33 +0000
@@ -0,0 +1,154 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Copyright (C) 2013
+#
+# Author: Daniel Chapman [e-mail]
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# 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 autopilot.input import Pointer, Mouse
+import tempfile
+import os
+
+
+class GeditAutopilotTestCase(AutopilotTestCase):
+
+    def setUp(self):
+        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
+        """
+        # gedit by default loads a blank document
+        # so start num at 1
+        num = 1
+        txt = text
+        
+        if txt == 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")
+  
+        while num < num_of_docs:
+            self.keyboard.press_and_release('Ctrl+n')
+            num +=1
+            if txt == 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")
+            
+
+        # lets just check we have the right amount of tabs
+        num_of_tabs = len(self.app.select_many('GeditView'))
+        self.assertTrue(num_of_tabs, Equals(num_of_docs))
+
+        # focus the required tab window
+        tab = str(tab_num)
+        self.keyboard.press_and_release('Alt+%s' % tab)
+        # check we are on the correct tab
+        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:
+            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")
+            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.keyboard.press_and_release('Ctrl+a')
+            self.keyboard.press_and_release('Delete')
+            #lets make sure we always save in /tmp
+            self.keyboard.type('/tmp/')
+            self.keyboard.press_and_release('Enter')
+            
+        if opn_dlg == 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")
+            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
+            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.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.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.pointing_device.click_object(self.search_entry)
+            #we are all set for the test now
+            
+            
\ No newline at end of file

=== added directory 'ubuntu_autopilot_tests/gedit/samples'
=== added file 'ubuntu_autopilot_tests/gedit/samples/gedit.c'
--- ubuntu_autopilot_tests/gedit/samples/gedit.c	1970-01-01 00:00:00 +0000
+++ ubuntu_autopilot_tests/gedit/samples/gedit.c	2013-08-14 17:04:33 +0000
@@ -0,0 +1,8 @@
+#include<stdio.h>
+
+main()
+{
+    printf("Hello Autopilot");
+
+
+}

=== added file 'ubuntu_autopilot_tests/gedit/samples/gedit.cpp'
--- ubuntu_autopilot_tests/gedit/samples/gedit.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu_autopilot_tests/gedit/samples/gedit.cpp	2013-08-14 17:04:33 +0000
@@ -0,0 +1,8 @@
+#include <iostream>
+using namespace std;
+
+int main ()
+{
+  cout << "Hello Autopilot!";
+  return 0;
+}
\ No newline at end of file

=== added file 'ubuntu_autopilot_tests/gedit/samples/gedit.py'
--- ubuntu_autopilot_tests/gedit/samples/gedit.py	1970-01-01 00:00:00 +0000
+++ ubuntu_autopilot_tests/gedit/samples/gedit.py	2013-08-14 17:04:33 +0000
@@ -0,0 +1,6 @@
+import re
+
+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

=== added file 'ubuntu_autopilot_tests/gedit/samples/gedit.vala'
--- ubuntu_autopilot_tests/gedit/samples/gedit.vala	1970-01-01 00:00:00 +0000
+++ ubuntu_autopilot_tests/gedit/samples/gedit.vala	2013-08-14 17:04:33 +0000
@@ -0,0 +1,9 @@
+class gedittest.HelloAutopilot : GLib.Object {
+
+    public static int main(string[] args) {
+
+        stdout.printf("Hello, Autopilot\n");
+
+        return 0;
+    }
+}
\ No newline at end of file

=== added file 'ubuntu_autopilot_tests/gedit/samples/gedit.xml'
--- ubuntu_autopilot_tests/gedit/samples/gedit.xml	1970-01-01 00:00:00 +0000
+++ ubuntu_autopilot_tests/gedit/samples/gedit.xml	2013-08-14 17:04:33 +0000
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<root>
+  <title>
+    Hello Autopilot
+  </title>
+  <para>
+    THis is just a sample paragraph  
+  </para>
+  <note>
+    and a sample note
+  </note>
+
+  <para>
+    This page written by: 
+    <ital>Dan Chapman</ital>
+  </para>
+  <para>
+    Copyright 2013
+  </para>
+</root>
\ No newline at end of file

=== added file 'ubuntu_autopilot_tests/gedit/samples/gedit1.c'
--- ubuntu_autopilot_tests/gedit/samples/gedit1.c	1970-01-01 00:00:00 +0000
+++ ubuntu_autopilot_tests/gedit/samples/gedit1.c	2013-08-14 17:04:33 +0000
@@ -0,0 +1,8 @@
+#include<stdio.h>
+
+main()
+{
+    printf("Hello Autopilot");
+
+
+}

=== added file 'ubuntu_autopilot_tests/gedit/samples/test'
--- ubuntu_autopilot_tests/gedit/samples/test	1970-01-01 00:00:00 +0000
+++ ubuntu_autopilot_tests/gedit/samples/test	2013-08-14 17:04:33 +0000
@@ -0,0 +1,1 @@
+Hello Autopilot
\ No newline at end of file

=== modified file 'ubuntu_autopilot_tests/gedit/test_gedit.py'
--- ubuntu_autopilot_tests/gedit/test_gedit.py	2013-05-29 19:37:09 +0000
+++ ubuntu_autopilot_tests/gedit/test_gedit.py	2013-08-14 17:04:33 +0000
@@ -1,360 +1,724 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Copyright (C) 2013
+#
+# Author: Daniel Chapman [e-mail]
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+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 gedit import GeditAutopilotTestCase
 from autopilot.testcase import AutopilotTestCase
-from autopilot.matchers import Eventually
-from testtools.matchers import Equals, NotEquals, Contains
-from autopilot.process import ProcessManager
-
-from time import sleep
-import tempfile
+import subprocess
+import testscenarios
 import os
-
-
-class GeditTests(AutopilotTestCase):
-    
-    def setUp(self):
-        super(GeditTests, self).setUp()
+import time
+import shutil
+
+class GeditKeyboardShortcutTests(GeditAutopilotTestCase):
+
+    def test_close_tab(self, ):
+        """ Using shortcut Ctrl+W """
+        # setup 2 blank documents
+        self.setup_test_docs(2)
+        num_before = len(self.app.select_many('GeditView'))
+        #close tab
+        self.keyboard.press_and_release('Ctrl+w')
+        #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))
+
+    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")
+
+    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
+        tabs = len(self.app.select_many('GeditTab'))
+        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)
+        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
+        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
+        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")
+
+    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")
+
+    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")
+
+    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")
+
+    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")
+
+    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")
+
+    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
+        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")
+
+    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
+        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')))
+        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")
+
+    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")
+
+    def test_redo_shortcut(self, ):
+        """ 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")
+        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")
+
+    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
+        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")
+
+    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
+        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
+                        Eventually(Equals('')),
+                        "Two possible reasons for fail: \
+                        1) Ctrl+a did not select text, \
+                        2) Ctrl+x did not cut text.")
+
+    def test_quit_gedit_shortcut(self, ):
+        """ Using shortcut Ctrl+q, test gedit quits """
+        self.keyboard.press_and_release('Ctrl+q')
+        # 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!"):
+            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
+        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
+        self.keyboard.press_and_release('F9')
+        self.assertThat(lambda: self.app.select_many('GeditPanel')[0].visible,
+                        Eventually(Equals(0)),
+                        "Side panel did not close after pressing F9")
+
+    def test_find_a_string_shortcut(self, ):
+        """ Using shortcut Ctrl+f test we can search for string """
+        #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
+        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")
+
+    #TODO:
+    #def test_find_next_instance_of_string_shortcut(self, ):
+    #    pass
+    #
+    #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
+    #    pass
+    #
+    #def test_go_to_line_shortcut(self, ):
+    #    #Ctrl+i
+    #    pass
+
+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
+        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
+        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")
+
+    def test_open_file_button(self, ):
+        """ 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")
+
+    def test_save_document_button(self, ):
+        """ Using save button, test the save dialog appears """
+        # create a doc with some text so we can save
+        self.setup_test_docs(1, text=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")
+
+    def test_print_document_button(self, ):
+        """ Using print button, test the print dialog opens """
+        self.setup_test_docs(1)
+        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")
+
+    def test_undo_button(self, ):
+        """ Test undo button, undoes last action """
+        self.setup_test_docs(1, text=True)
+        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")
+
+    def test_redo_button(self, ):
+        """ Test redo button, redoes the last undo action """
+        self.setup_test_docs(1, text=True)
+        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")
+
+    def test_cut_button(self, ):
+        """ Test the cut button cuts the selected text """
+        self.setup_test_docs(1, text=True)
+        self.keyboard.press_and_release('Ctrl+a')
+        self.pointing_device.click_object(
+            self.app.select_single('GtkToolButton',
+                                   name='EditCut'))
+        #test it cut the selected text
+        self.assertThat(lambda: self.app.select_many('GeditView')[0].buffer,
+                        Eventually(Equals('')),
+                        "Two possible reasons for fail: \
+                        1) Ctrl+a did not select text, or \
+                        2) Cut button did not cut text.")
+
+    def test_copy_and_paste_buttons(self, ):
+        """ test we can copy and paste using buttons """
+        self.setup_test_docs(1, text=True)
+        self.keyboard.press_and_release('Ctrl+a')
+        #copy text
+        self.pointing_device.click_object(
+            self.app.select_single('GtkToolButton',
+                                   name='EditCopy'))
+        self.keyboard.press_and_release('Right')
+        # now paste
+        self.pointing_device.click_object(
+            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")
+
+    def test_search_button(self, ):
+        """ Test the search button opens the search box """
+        self.setup_test_docs(1, text=True)
+        self.pointing_device.click_object(
+            self.app.select_single('GtkToolButton',
+                                   name='SearchFind'))
+        self.keyboard.type('fox\n')
+        #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")
+
+    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")
+
+    def test_window_visible(self, ):
+        """ Test the window loads """
+        self.assertThat(lambda: self.app.select_single('GeditWindow').visible,
+                        Eventually(Equals(1)),
+                        "Gedit window did not open")
+
+    def test_window_title(self, ):
+        """ Test the window title is correct """
+        self.assertThat(lambda: self.app.select_single('GeditWindow').title,
+                        Eventually(Equals("Untitled Document 1 - gedit")),
+                        "Gedit window did not match")
+
+    def test_tab_name(self, ):
+        """ Test the tab displays name """
+        self.assertThat(lambda: self.app.select_many('GeditTab')[0].name,
+                        Eventually(Equals("Untitled Document 1")))
+
+    # CAN WE ACCESS THE BOTTOM COMBOBOX'S????????????
+
+class GeditSidebarTests(GeditAutopilotTestCase):
+
+    def test_close_sidebar_button(self, ):
+        #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
+        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
+
+
+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"}),
+            ]
+    
+    def test_save_file_type_tests(self, ):
+        #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
+        self.keyboard.type(self.input)
+        #click save
+        
+        self.pointing_device.click_object(
+            save_dlg.select_single('GtkLabel', label='_Save'))
+        #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)
+        filename = self.input
+        
+        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')
+        # 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")
+            
+    def test_cancel_button_closes_dialog(self, ):
+        self.setup_test_docs(1, save_dlg=True)
+        save_dialog = self.app.select_single('GeditFileChooserDialog')
+        self.pointing_device.click_object(
+            save_dialog.select_single('GtkLabel',
+                                      label='_Cancel'))
+        # 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")
+        
+    def test_new_folder_button(self, ):
+        self.setup_test_docs(1, save_dlg=True)
+        save_dialog = self.app.select_single('GeditFileChooserDialog')
+        self.pointing_device.click_object(
+            save_dialog.select_single('GtkButton',
+                                      label='Create Fo_lder'))
+        self.keyboard.type('test_folder\n')
+        self.assertThat('/tmp/test_folder', DirExists())
+        self.addCleanup(os.rmdir, '/tmp/test_folder')
+
+class GeditOpenFileTypesTests(GeditAutopilotTestCase):
+    scenarios = [
+        ('test_file', {'input': "test"}),
+        ('py_file', {'input': "gedit.py"}),
+        ('c_file', {'input': "gedit1.c"}),
+        ('cpp_file', {'input': "gedit.cpp"}),
+        ('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)
+        dialog = self.app.select_single('GeditFileChooserDialog')
+        self.pointing_device.click_object(dialog.select_single('GtkLabel',
+                                                               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.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")
+    
+    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")
+        open_dialog = self.app.select_single('GeditFileChooserDialog')
+        self.pointing_device.click_object(
+            open_dialog.select_single('GtkLabel',
+                                      label='_Cancel'))
+        # 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")
+    
+    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")
+        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")
+    
+
+class GeditReplaceDialogTests(GeditAutopilotTestCase):
+
+    def test_find_and_replace_buttons(self, ):
+        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.replace_entry)
+        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
+        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')))
+    
+    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
+        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
+        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')))
+        
+    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
+        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
+        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.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')))
+    
+    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")
+    
+    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")
+    
+
+class GeditSingleFileCommandLineTest(AutopilotTestCase):
+    
+    def setUp(self):
+        super(GeditSingleFileCommandLineTest, self).setUp()
+        sample_file = 'test'
+        for root, dirs, files in os.walk(os.getcwd()):
+            for name in files:
+                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
+    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'
+        for root, dirs, files in os.walk(os.getcwd()):
+            for name in dirs:
+                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')
+        
+    def test_open_multi_files(self, ):
+        
+        #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
+        self.assertThat(len(self.gedit.select_many('GeditTab')), Equals(4))
+        #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_save_and_open_a_file(self):
-        #Test-case name: gedit/ged-001
-        #This test will check that GEdit can save and open saved files
-        #close the original blank document
-        self.keyboard.press_and_release("Ctrl+w")
-
-        #documents = self.app.select_single('GeditTab')
-        #self.assertThat(lambda: self.app.select_single('GeditTab').name, Eventually(Contains(fileName)))
-
-        documents = self.app.select_many('GeditTab')
-        self.assertThat(lambda: len(documents), Eventually(Equals(0)))
-
-        #open a new blank document
-        btn = self.app.select_single('GtkToolButton', label='_New')
-        self.assertThat(btn, NotEquals(None))
-        self.mouse.move_to_object(btn)
-        self.mouse.click()
-
-        #hacky delay to wait
-        sleep(1)
-
-        self.keyboard.type("The quick brown foxes jump over the lazy dog")
-
-        #save file
-        tempFile = _generateTempFileName()
-        self._saveFile(tempFile)
-
-        #Close the open file
-        self.keyboard.press_and_release("Ctrl+w")
-
-        #Make sure it closed
-        documents = self.app.select_many('GeditTab')
-        self.assertThat(lambda: len(documents), Eventually(Equals(0)))
-
-        #Open the file we made
-        btn = self.app.select_single('GeditOpenToolButton', label='Open')
-        self.assertThat(btn, NotEquals(None))
-        self.mouse.move_to_object(btn)
-        self.mouse.click()
-
-        #hacky delay wait for window to appear :-(
-        sleep(3)
-
-        #Manually type location
-        self.keyboard.type(tempFile + "\n")
-
-        #Check to see that the title reflects our filename
-        #(dirName, fileName) = os.path.split(tempFile)
-        #documents = self.app.select_single('GeditTab')
-        #self.assertThat(lambda: documents[0].name, Eventually(Contains(fileName)))
-
-        #Check that the file contains the phrase "The quick brown foxes jump over the lazy dog"
-        filePhrase = open(tempFile, 'r')
-        self.assertThat(filePhrase, Contains("The quick brown foxes jump over the lazy dog\n"))
-
-        #Close the open file
-        self.keyboard.press_and_release("Ctrl+w")
-
-        #Delete the file we made
-        #Added sleep so file does not get removed too soon
-        sleep(1)
-        self.addCleanup(os.remove, tempFile)
-
-    def test_replace_test(self):
-        #Test-case name: gedit/ged-003
-        #This test will check that GEdit can replace text
-
-        #Type in phrase
-        self.keyboard.type("The quick brown foxes jump over the lazy dog")
-
-        #Press ctrl+h to open replace dialog
-        self.keyboard.press_and_release("Ctrl+h")
-
-        #Verify replace dialog appears
-        #TODO
-
-        #Replace foxes with fox
-        self.keyboard.type("foxes\t\tfox")
-        self.keyboard.press_and_release("Alt+a")
-
-        #Verify replace dialog stays open
-        #TODO
-
-        #Close replace dialog
-        self.keyboard.press_and_release("Escape")
-
-        #Save file
-        tempFile = _generateTempFileName()
-        print "tempFile " + tempFile
-        self._saveFile(tempFile)
-
-        #Verify text now reads 'The quick brown fox jump over the lazy dog'
-        savedFile = open(tempFile, "r")
-        filePhrase = savedFile.read()
-        self.assertThat(filePhrase, Contains("The quick brown fox jump over the lazy dog\n"))
-
-        #Close the open file
-        self.keyboard.press_and_release("Ctrl+w")
-
-        #Delete the file we made
-        sleep(3)
-        self.addCleanup(os.remove, tempFile)
-
-    def test_recent_documents(self):
-        #GeditOpenToolButton tooltip_text Open '/tmp/'
-        recentBtn = self.app.select_single('GeditOpenToolButton', label='Open')
-        self.assertThat(recentBtn, NotEquals(None))
-        self.mouse.move_to_object(recentBtn)
-        self.mouse.click()
-        #inserted sleep to see the recent files otherwise window closes too quicly
-        sleep(2)
-        
-    def test_highlight_searched_text(self):
-        #Test-case name: gedit/ged-004
-        #This test will check that GEdit can find and highlight searched text
-
-        #Type in phrase
-        self.keyboard.type("The quick brown foxes jump over the lazy dog")
-
-        #Press Ctrl+f to open search box
-        self.keyboard.press_and_release("Ctrl+f")
-
-        #Verify search box appears
-        #TODO
-
-        #Type in "T"
-        self.keyboard.type("T")
-        sleep(3)
-
-        #Verify all the "T" letters in the document are highlighted
-        #TODO
-
-        #Type in "he"
-        self.keyboard.type("he")
-
-        #Verify all the "The" words in the document are highlighted
-        #TODO
-
-        #Press Ctrl+g to go to the next searched word
-        self.keyboard.press_and_release("Ctrl+g")
-
-        #Verify that text cursor moves to grey-highlighted 'the' in 'over the lazy dog'
-        #TODO
-
-        #Press Shift+Ctrl+g to go to the previous searched word
-        self.keyboard.press_and_release("Shift+Ctrl+g")
-
-        #Verify that text cursor moves to grey-highlighted 'The' in 'The quick brown'
-        #TODO
-
-        #Close search box
-        self.keyboard.press_and_release("Escape")
-
-        #Verify that the seach box is closed
-        #TODO
-
-        #Verify all the "The" words in the document are highlighted
-        #TODO
-
-        #Close the open file
-        self.keyboard.press_and_release("Ctrl+w")
-
-        #Don't save
-        sleep(3)
-        self.keyboard.press_and_release("Alt+w")
-
-    def test_display_file_browser_panel(self):
-        #Test-case name: gedit/ged-005
-        #This test will check that GEdit can display File Browser panel
-
-        #These property's exist
-        #GeditCloseButton tooltip_text "Hide panel"
-        #GtkPaned GtkBox GtkBox GtkBox GtkLabel label "Documents"
-        #GtkPaned GtkBox GtkBox GtkBox GtkLabel label "File Browser"
-        #GtkFileBrowserWidget
-        #GeditDocumentsPanel
-        #GtkWindow GtkMenu GtkLabel label "Documents"
-        #GtkWindow GtkMenu GtkLabel label "File Browser"
-
-        #Press Alt+e to open "Edit" menu
-        self.keyboard.press_and_release("Alt+e", delay=0.5)
-
-        #Press "e" to open "Preferences"
-        self.keyboard.press_and_release("e")
-
-        #combo_box_widget = self.app.select_single('ComboBox', name='foobar', someOtherProperty=123)
-
-        #Press left arrow  "Plugins" tab
-        self.keyboard.press_and_release("Left")
-
-        #Verify the "File Browser Panel" plugin is checked
-        #TODO
-
-        #Press Escape to close preferences window
-        self.keyboard.press_and_release("Escape")
-
-        #Press F9
-        self.keyboard.press_and_release("F9")
-
-        #Verify the The side panel appears with the file browser panel included
-        #should spawn "Documents"
-        #introspection
-        #self.assertThat(self.app.select_many('GtkLabel', label='Documents'), NotEquals(None))
-
-        #Press F9
-        self.keyboard.press_and_release("F9")
-
-        #Verify the The side panel close properly
-        #this seems to stick around the tree -- look for visible property?
-        #self.assertThat(self.app.select_many('GtkLabel', label='Documents'), Equals(None))
-        #self.assertThat(self.app.select_many('GeditCloseButton', tooltip_text='Hide panel'), Equals(None))
-
-    def test_tab_manipulation(self):
-        return
-        #test using alt keys to move between docus
-        #test using ctrl+w to close tabs
-        #test ctrl+t for new tabs
-        #test button for new tab
-        #test creating tab group
-        #test moving tab group to new window
-
-    #def test_insert_overwrite_mode(self):
-        #verify we are in insert mode
-        #GeditWindow GtkBox GeditStatusbar GtkLabel
-        #typeMode = self.app.select_single('GtkLabel', label=' INS ')
-        #typeMode = self.app.select_many('GtkLabel', label=' INS ')
-        #self.assertThat(typeMode, NotEquals(None))
-
-
-        #type out some words
-
-        #turn on overwrite, and press home
-        #self.keyboard.press_and_release("Home")
-        #self.keyboard.press_and_release("Insert")
-        #self.assertThat(typeMode.label, Equals(' OVR '))
-        
-
-        #type over the first word
-        #turn on insert
-        #add a word in the middle
-        #save file and check result matches
-
-    def test_shortcuts(self):
-        return
-        #test search, go to line
-        #plugin! test edit, insert date and time
-        #test copy and paste into doc
-        #test save all
-        #test close all
-        #test revert
-        #test undo and redo
-
-    def test_toolbar(self):
-        #test new
-        #GeditWindow GtkBox GtkToolbar GtkToolButton
-        #grab the file new button
-        btn = self.app.select_single('GtkToolButton', label='_New')
-
-        #does it exist?
-        self.assertThat(btn, NotEquals(None))
-
-        #let's click it to open a new document
-        documents = self.app.select_many('GeditTab')
-        orginalNumDocuments = len(documents)
-        self.mouse.move_to_object(btn)
-        self.mouse.click()
-
-        #let's re-grab the open documents
-        documents = self.app.select_many('GeditTab')
-
-        #do we have another document now?
-        self.assertThat(lambda: len(documents), Eventually(Equals(orginalNumDocuments + 1)))
-
-        #is it a new untitled document?
-        #This will grab the current window title, 'Untitled Document # - gedit', but the untitled document is translated. For now, we'll ignore the translatable text to ensure compatibility
-        documents = self.app.select_many('GeditTab')
-        #note index starts at 0
-        self.assertThat(documents[orginalNumDocuments].name, Contains(str(orginalNumDocuments + 1)))
-
-        #test open
-        btn = self.app.select_single('GeditOpenToolButton', label='Open')
-        self.assertThat(btn, NotEquals(None))
-
-        #test save
-        btn = self.app.select_single('GtkToolButton', label='Save')
-        self.assertThat(btn, NotEquals(None))
-
-        #test print
-        btn = self.app.select_single('GtkToolButton', label='Print')
-        self.assertThat(btn, NotEquals(None))
-
-        #test undo
-        btn = self.app.select_single('GtkToolButton', label='_Undo')
-        self.assertThat(btn, NotEquals(None))
-
-        #test redo
-        btn = self.app.select_single('GtkToolButton', label='_Redo')
-        self.assertThat(btn, NotEquals(None))
-
-        #test cut
-        btn = self.app.select_single('GtkToolButton', label='Cu_t')
-        self.assertThat(btn, NotEquals(None))
-
-        #test copy
-        btn = self.app.select_single('GtkToolButton', label='_Copy')
-        self.assertThat(btn, NotEquals(None))
-
-        #test paste
-        btn = self.app.select_single('GtkToolButton', label='_Paste')
-        self.assertThat(btn, NotEquals(None))
-
-        #test search
-        btn = self.app.select_single('GtkToolButton', label='Find')
-        self.assertThat(btn, NotEquals(None))
-
-        #test replace
-        btn = self.app.select_single('GtkToolButton', label='Replace')
-        self.assertThat(btn, NotEquals(None))
-
-    def _saveFile(self, saveName):
-        saveBtn = self.app.select_single('GtkToolButton', label='Save')
-        self.assertThat(saveBtn, NotEquals(None))
-        self.mouse.move_to_object(saveBtn)
-        self.mouse.click()
-
-        #hacky delay wait for window to appear :-(
-        sleep(3)
-
-        self.keyboard.type(saveName)
-        self.keyboard.press_and_release("Alt+s")
-
-        #Check to see that the title reflects our filename
-        (dirName, fileName) = os.path.split(saveName)
-        documents = self.app.select_many('GeditTab')
-        self.assertThat(documents[len(documents) - 1].name, Eventually(Contains(fileName)))
-
-        #An asterisk in a gedit title means an unsaved document
-        self.assertNotIn(documents[len(documents) - 1].name, "*")
-
-def _generateTempFileName():
-    #Create temporary file, then close it, so we can re-use the file name
-    sFile = tempfile.NamedTemporaryFile()
-    sFile.close()
-    return sFile.name
+        
+    
+    def test_new_doc_arg(self, ):
+        #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
+        subprocess.check_call(["gedit", "--new-document"])
+        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
+
+        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
+        self.assertThat(len(self.app.select_many('GeditWindow')), Equals(2))