Merge lp:~dpniel/ubiquity/autopilot into lp:ubiquity

[Dan Chapman ]

This fixes the bug 1255589, but also further improving the way the test checks the english values.

AT the start of the test we generate a config file in /tmp/english_config.ini which contains the correct strings based on the flavor being installed. Then if english is the selected language all object values that are in the config will get tested against the objects labels throughout the install.

I removed alot of repetitive code checking visible, string, unicode properties of objects. SO now all objects are passed to either check_visible or check_hidden functions which accepts either a object name or a list of names, and its during this stage that the english values will get tested if they are present in the config file

This fix changes nothing for Ubuntu but causes all the other flavors to fail due to 'Ubuntu' being present in some object labels instead of the actual flavors name. But at least its picking up a legitimate bug.

Also added checks for U1 labels and improved the handling of waiting on the progress bar to complete and check no error dialogs appear while waiting and also on page change.

[lp:~dpniel/ubiquity/autopilot]

6073. By Dan Chapman  on 2013-11-27

disabled xterm from launching in run-autopilot.sh

6074. By Dan Chapman  on 2013-11-29

Merged progress page and Ubuntu one improvments into this MP

6075. By Dan Chapman  on 2013-11-29

fix pyflakes

6076. By Dan Chapman  on 2013-11-29

disable xterm

6077. By Dan Chapman  on 2013-11-29

fixed conflict

6078. By Dan Chapman  on 2013-11-29

Added options for selecting edubuntu desktop env

[Jean-Baptiste Lallement (jibel)]

Approved, thanks!

I tried with ubuntu english and non-english tests cases. Lubuntu and Xubuntu images seems broken (I tried with the current version too, so at least it is not a regression)

pep8 and pyflakes tests are ok.

review: Approve

=== added file 'autopilot/launch_vis'
--- autopilot/launch_vis	1970-01-01 00:00:00 +0000
+++ autopilot/launch_vis	2013-11-29 17:06:55 +0000
@@ -0,0 +1,9 @@
+#!/bin/sh
+. /var/log/installer/autopilot
+export DBUS_SESSION_BUS_ADDRESS
+export UBIQUITY_PID
+
+# Disable X access control to let root access :0
+xhost +
+#launch vis using autopilot py2
+sudo -E autopilot vis

=== modified file 'autopilot/ubiquity-autopilot-runner/custom-installation/iso-override/usr/local/bin/run-autopilot.sh'
--- autopilot/ubiquity-autopilot-runner/custom-installation/iso-override/usr/local/bin/run-autopilot.sh	2013-11-28 06:21:02 +0000
+++ autopilot/ubiquity-autopilot-runner/custom-installation/iso-override/usr/local/bin/run-autopilot.sh	2013-11-29 17:06:55 +0000
@@ -150,10 +150,12 @@
 
     [ -e "$flag" ] && return 0
 
+
     if [ $DEBUG -ne 0 ]; then
         # Put here everything you want to run in debug mode
         xterm &  # Easier to debug from a live session, and rarely broken
     fi
+
     sudo stty -F /dev/ttyS0 raw speed 115200
     
     tail_logs $SESSION_LOG /var/log/syslog

=== removed file 'autopilot/ubiquity_autopilot_tests/configs/eng_label_values.py'
--- autopilot/ubiquity_autopilot_tests/configs/eng_label_values.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/configs/eng_label_values.py	1970-01-01 00:00:00 +0000
@@ -1,102 +0,0 @@
-# Config file for english label values
-# Author: Dan Chapman <[e-mail]>
-# Copyright (C) 2013
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3 as
-# published by the Free Software Foundation.
-#
-# 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-def get_distribution():
-    """Returns the name of the running distribution."""
-    with open('/cdrom/.disk/info') as f:
-        for line in f:
-            distro = line[:max(line.find(' '), 0) or None]
-            if distro:
-                return str(distro)
-            raise SystemError("Could not get distro name")
-
-distro_flavor = get_distribution()
-
-stepLanguage = {
-    "release_notes_label": 'You may wish to read the <a href="release-notes">'
-    'release notes</a>.',
-    "page_title": 'page_title= <span size="xx-large">Welcome</span>'
-}
-
-stepPrepare = {
-    "page_title": '<span size="xx-large">Preparing to install {0}</span>'
-    .format(distro_flavor),
-    "prepare_best_results": 'For best results, please ensure that this '
-    'computer:',
-    "prepare_foss_disclaimer": 'Ubuntu uses third-party software to play '
-    'Flash, MP3 and other media, and to work with some graphics and wi-fi '
-    'hardware. Some of this software is proprietary. The software is subject '
-    'to license terms included with its documentation.',
-    "prepare_download_updates": 'Download updates while installing',
-    "prepare_nonfree_software": 'Install this third-party software',
-    "prepare_network_connection": 'is connected to the Internet',
-    "prepare_sufficient_space": 'has at least 6.0 GB available drive space'
-}
-
-
-stepPartAsk = {
-    "page_title": '<span size="xx-large">Installation type</span>',
-    "use_device": 'Erase disk and install {0}'.format(distro_flavor),
-    "use_device_desc": '<span size="small"><span foreground="darkred">'
-    'Warning:</span> This will delete any files on the disk.</span>',
-    "use_crypto": 'Encrypt the new Ubuntu installation for security',
-    "use_crypto_desc": '<span size="small">You will choose a security key in '
-    'the next step.</span>',
-    "use_lvm": 'Use LVM with the new Ubuntu installation',
-    "use_lvm_desc": '<span size="small">This will set up Logical Volume '
-    'Management. It allows taking snapshots and easier partition '
-    'resizing.</span>',
-    "custom_partitioning": 'Something else',
-    "custom_partitioning_desc": '<span size="small">You can create or resize '
-    'partitions yourself, or choose multiple partitions for Ubuntu.</span>'
-}
-
-
-stepPartCrypto = {
-    "page_title": '<span size="xx-large">Choose a security key:</span>',
-    "verified_crypto_label": 'Confirm the security key:',
-    "crypto_label": 'Choose a security key:',
-    "crypto_description": 'Disk encryption protects your files in case you '
-    'lose your computer. It requires you to enter a security key each time '
-    'the computer starts up.',
-    "crypto_warning": '<span foreground="darkred">Warning:</span> If you lose '
-    'this security key, all data will be lost. If you need to, write down '
-    'your key and keep it in a safe place elsewhere.',
-    "crypto_extra_label": 'For more security:',
-    "crypto_extra_time": 'The installation may take much longer.',
-    "crypto_description_2": 'Any files outside of Ubuntu will not be '
-    'encrypted.',
-    "crypto_overwrite_space": 'Overwrite empty disk space'
-}
-
-stepLocation = {
-    "page_title": '<span size="xx-large">Where are you?</span>'
-}
-
-stepKeyboardConf = {
-    "page_title": '<span size="xx-large">Keyboard layout</span>'
-}
-
-stepUserInfo = {
-    "page_title": '<span size="xx-large">Who are you?</span>',
-    "hostname_label": "Your computer's name:",
-    "username_label": 'Pick a username:',
-    "password_label": 'Choose a password:',
-    "verified_password_label": 'Confirm your password:',
-    "hostname_extra_label": 'The name it uses when it talks to other '
-    'computers.'
-}

=== added file 'autopilot/ubiquity_autopilot_tests/configs/english_label_conf.py'
--- autopilot/ubiquity_autopilot_tests/configs/english_label_conf.py	1970-01-01 00:00:00 +0000
+++ autopilot/ubiquity_autopilot_tests/configs/english_label_conf.py	2013-11-29 17:06:55 +0000
@@ -0,0 +1,170 @@
+# Config file for english label values
+# Author: Dan Chapman <[e-mail]>
+# Copyright (C) 2013
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import configparser
+
+
+def get_distribution():
+    """Returns the name of the running distribution."""
+    with open('/cdrom/.disk/info') as f:
+        for line in f:
+            distro = line[:max(line.find(' '), 0) or None]
+            if distro:
+                return str(distro)
+            raise SystemError("Could not get distro name")
+
+
+def generate_config():
+    distro_flavor = get_distribution()
+    config = configparser.ConfigParser()
+
+    #CREATE STEP LANGUAGE CONFIG
+    config['stepLanguage'] = {}
+    stepLanguage = config['stepLanguage']
+    stepLanguage['release_notes_label'] = \
+        'You may wish to read the <a href="release-notes">release notes</a>.'
+    stepLanguage["page_title"] = \
+        '<span size="xx-large">Welcome</span>'
+
+    # CREATE STEP PREPARE CONFIG
+    config['stepPrepare'] = {}
+    stepPrepare = config['stepPrepare']
+    stepPrepare['page_title'] = \
+        '<span size="xx-large">Preparing to install {0}</span>'\
+        .format(distro_flavor)
+    stepPrepare['prepare_best_results'] = \
+        'For best results, please ensure that this computer:'
+    stepPrepare['prepare_foss_disclaimer'] = \
+        '{0} uses third-party software to play ' \
+        'Flash, MP3 and other media, and to work with some graphics ' \
+        'and wi-fi hardware. Some of this software is proprietary. ' \
+        'The software is subject to license terms included with its ' \
+        'documentation.'.format(distro_flavor)
+    stepPrepare['prepare_download_updates'] = \
+        'Download updates while installing'
+    stepPrepare['prepare_nonfree_software'] = \
+        'Install this third-party software'
+    stepPrepare['prepare_network_connection'] = \
+        'is connected to the Internet'
+    stepPrepare['prepare_sufficient_space'] = \
+        'has at least 6.0 GB available drive space'
+
+    #CREATE STEP PART ASK CONFIG
+    config['stepPartAsk'] = {}
+    stepPartAsk = config['stepPartAsk']
+    stepPartAsk['page_title'] = \
+        '<span size="xx-large">Installation type</span>'
+    stepPartAsk['use_device'] = \
+        'Erase disk and install {0}'.format(distro_flavor)
+    stepPartAsk['use_device_desc'] = \
+        '<span size="small"><span foreground="darkred">Warning:</span> ' \
+        'This will delete any files on the disk.</span>'
+    stepPartAsk['use_crypto'] = \
+        'Encrypt the new Ubuntu installation for security'
+    stepPartAsk['use_crypto_desc'] = \
+        '<span size="small">You will choose a security key in the ' \
+        'next step.</span>'
+    stepPartAsk['use_lvm'] = 'Use LVM with the new {0} installation'.format(
+        distro_flavor
+    )
+    stepPartAsk['use_lvm_desc'] = \
+        '<span size="small">This will set up Logical Volume ' \
+        'Management. It allows taking snapshots and easier partition ' \
+        'resizing.</span>'
+    stepPartAsk['custom_partitioning'] = 'Something else'
+    stepPartAsk['custom_partitioning_desc'] = \
+        '<span size="small">You can create or resize partitions yourself, ' \
+        'or choose multiple partitions for {0}.</span>'.format(distro_flavor)
+
+    #CREATE STEP PART CRYPTO CONFIG
+    config['stepPartCrypto'] = {}
+    stepPartCrypto = config['stepPartCrypto']
+    stepPartCrypto["page_title"] = \
+        '<span size="xx-large">Choose a security key:</span>'
+    stepPartCrypto["verified_crypto_label"] = 'Confirm the security key:'
+    stepPartCrypto["crypto_label"] = 'Choose a security key:'
+    stepPartCrypto["crypto_description"] = \
+        'Disk encryption protects your files in case you lose your computer.' \
+        ' It requires you to enter a security key each time the computer ' \
+        'starts up.'
+    stepPartCrypto["crypto_warning"] = \
+        '<span foreground="darkred">Warning:</span> If you lose ' \
+        'this security key, all data will be lost. If you need to, ' \
+        'write down your key and keep it in a safe place elsewhere.'
+    stepPartCrypto["crypto_extra_label"] = 'For more security:'
+    stepPartCrypto["crypto_extra_time"] = \
+        'The installation may take much longer.'
+    stepPartCrypto["crypto_description_2"] = \
+        'Any files outside of Ubuntu will not be encrypted.'
+    stepPartCrypto["crypto_overwrite_space"] = 'Overwrite empty disk space'
+
+    #CREATE STEP LOCATION CONFIG
+    config['stepLocation'] = {}
+    stepLocation = config['stepLocation']
+    stepLocation["page_title"] = '<span size="xx-large">Where are you?</span>'
+
+    #CREATE STEP KEYBOARD CONFIG
+    config['stepKeyboardConf'] = {}
+    stepKeyboardConf = config['stepKeyboardConf']
+    stepKeyboardConf["page_title"] = \
+        '<span size="xx-large">Keyboard layout</span>'
+
+    #CREATE STEP USER INFO CONFIG
+    config['stepUserInfo'] = {}
+    stepUserInfo = config['stepUserInfo']
+    stepUserInfo["page_title"] = '<span size="xx-large">Who are you?</span>'
+    stepUserInfo["hostname_label"] = "Your computer's name:"
+    stepUserInfo["username_label"] = 'Pick a username:'
+    stepUserInfo["password_label"] = 'Choose a password:'
+    stepUserInfo["verified_password_label"] = 'Confirm your password:'
+    stepUserInfo["hostname_extra_label"] = \
+        'The name it uses when it talks to other computers.'
+
+    #CREATE STEP UBUNTU 1 CONFIG
+    config['stepUbuntuOne'] = {}
+    stepUbuntuOne = config['stepUbuntuOne']
+    stepUbuntuOne['u1_about_label'] = 'Ubuntu One is the single account you ' \
+        'use to log in to all services and sites related to Ubuntu.\n\nGet ' \
+        'new apps from the Software Center, store files in your personal ' \
+        'cloud, buy tracks from the Music Store, manage your payments and ' \
+        'subscriptions - you decide which services you need.\n\nIf you have ' \
+        'an existing Ubuntu single sign on account, that is now called your ' \
+        'Ubuntu One account.'
+    stepUbuntuOne['cloud_label'] = 'Cloud'
+    stepUbuntuOne['music_label'] = 'Music'
+    stepUbuntuOne['photos_label'] = 'Photos'
+    stepUbuntuOne['apps_label'] = 'Apps'
+    stepUbuntuOne['u1_existing_account'] = \
+        'I am a returning Ubuntu One user and my password is:'
+    stepUbuntuOne['u1_new_account'] = 'I am a new Ubuntu One user.'
+    stepUbuntuOne['u1_explain_email_2'] = '<span size="small">If you ' \
+        'don\'t have an account yet, don\'t worry we\'ll create one for ' \
+        'you.</span>'
+    stepUbuntuOne['u1_explain_email'] = '<span size="small">Enter the email ' \
+        'address you use to log into your Ubuntu One account.</span>'
+    stepUbuntuOne['u1_terms'] = \
+        'I have read and accept the <a href="">Ubuntu One terms of use</a>'
+    stepUbuntuOne['u1_tc_check'] = ''
+    stepUbuntuOne['password_mismatch'] = 'Passwords do not match'
+    stepUbuntuOne['u1_ask_name_pass'] = \
+        'Please tell us your name and choose a password:'
+    stepUbuntuOne['u1_ask_email1'] = 'Please type your email:'
+    stepUbuntuOne['u1_no_internet'] = 'There is no internet connection. ' \
+        'To be able to create an account or to log in to Ubuntu One, you ' \
+        'need to be connected to the internet.'
+
+    #write config to tmp file
+    with open('/tmp/english_config.ini', 'w') as configfile:
+        config.write(configfile)

=== modified file 'autopilot/ubiquity_autopilot_tests/emulators/gtktoplevel.py'
--- autopilot/ubiquity_autopilot_tests/emulators/gtktoplevel.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/emulators/gtktoplevel.py	2013-11-29 17:06:55 +0000
@@ -25,7 +25,6 @@
     import Config4, Config5, Config6
 from ubiquity_autopilot_tests.emulators\
     import gtkcontrols, gtkaccessible, gtkcontainers
-import time
 import logging
 logger = logging.getLogger(__name__)
 
@@ -96,79 +95,6 @@
         logger.debug('Returning {0} object'.format(dialogType))
         return dialog
 
-    def run_install_progress_page_tests(self, ):
-        ''' Runs the test for the installation progress page
-
-            This method tracks the current progress of the install
-            by using the fraction property of the progress bar
-            to assertain the percentage complete.
-
-        '''
-        logger.debug("run_install_progress_page_tests()")
-        #We cant assert page title here as its an external html page
-        #Maybe try assert WebKitWebView is visible
-        webkitwindow = self.select_single('GtkScrolledWindow',
-                                          name='webkit_scrolled_window')
-        expectThat(webkitwindow.visible).equals(
-            True, msg="Expected the slideshow to be visible, but it wasn't")
-
-        #Can we track the progress percentage?
-        self.install_progress = self.select_single('GtkProgressBar',
-                                                   name='install_progress')
-
-    #Copying files progress bar
-        self._track_install_progress_bar()
-
-        self.install_progress.fraction.wait_for(0.0, timeout=120)
-        #And now the install progress bar
-        self._track_install_progress_bar()
-
-    def _track_install_progress_bar(self):
-        '''Gets the value of the fraction property of the progress bar
-
-            so we can see when the progress bar is complete
-
-        '''
-        logger.debug("_track_install_progress_bar()")
-        progress = 0.0
-        complete = 1.0
-        logger.debug('Percentage complete "{0:.0f}%"'.format(progress * 100))
-        while progress < complete:
-            #keep updating fraction value
-            progress = self.install_progress.fraction
-            # lets sleep for a second on each loop until we get near the end of
-            # the progress bar
-            if progress < 0.7:
-                time.sleep(1)
-
-            logger.debug('Percentage complete "{0:.0f}%"'
-                         .format(progress * 100))
-            #check for install errors while waiting
-            try:
-                crash_dialog = self.get_dialog('GtkDialog',
-                                               BuilderName='crash_dialog')
-                logger.debug("Checking crash dialog hasn't appeared....")
-                if crash_dialog.visibe:
-                    logger.error("Crash Dialog appeared")
-                    assert not crash_dialog.visible,\
-                        "Crash Dialog appeared! Something went wrong!!!"
-                    progress = 1.0
-            except Exception:
-                pass
-            # Lets try and grab the grub failed message box on the fly
-            try:
-                logger.debug("Checking failed grub install dialog hasn't "
-                             "appeared.......")
-                grub_dialog = self.get_dialog('GtkMessageDialog')
-                if grub_dialog.visible:
-                    logger.error("The Grub installation failed dialog "
-                                 "appeared :-(")
-                    assert grub_dialog.visible != 1,\
-                        "The Grub installation failed"
-                    progress = 1.0
-            except Exception:
-                pass
-
 
 class GtkDialog(GtkWindow):
     """ Emulator class for a GtkDialog, """

=== modified file 'autopilot/ubiquity_autopilot_tests/tests/__init__.py'
--- autopilot/ubiquity_autopilot_tests/tests/__init__.py	2013-11-22 12:29:14 +0000
+++ autopilot/ubiquity_autopilot_tests/tests/__init__.py	2013-11-29 17:06:55 +0000
@@ -20,6 +20,7 @@
 import logging
 import random
 import time
+import configparser
 
 from testtools.matchers import Equals, NotEquals
 
@@ -34,7 +35,7 @@
 from ubiquity_autopilot_tests.emulators.gtktoplevel import GtkWindow
 from ubiquity_autopilot_tests.emulators import AutopilotGtkEmulatorBase
 from ubiquity_autopilot_tests.testcase import UbiquityTestCase
-from ubiquity_autopilot_tests.configs import eng_label_values
+from ubiquity_autopilot_tests.configs import english_label_conf
 from ubiquity_autopilot_tests.configs.partconfig import (
     Config1,
     Config2,
@@ -49,6 +50,7 @@
 
 
 class UbiquityAutopilotTestCase(UbiquityTestCase):
+
     def setUp(self):
         super(UbiquityAutopilotTestCase, self).setUp()
         self.app = self.launch_application()
@@ -60,7 +62,11 @@
         self.current_step = ''
         self.step_before = ''
         self.english_install = False
-        self.eng_config = {}
+        english_label_conf.generate_config()
+        self.english_config = configparser.ConfigParser()
+        self.english_config.read('/tmp/english_config.ini')
+        #delete config at end of test
+        self.addCleanup(os.remove, '/tmp/english_config.ini')
 
     def launch_application(self):
         '''
@@ -92,6 +98,8 @@
 
         """
         logger.debug('go_to_next_page(wait={0})'.format(wait))
+        # check no error dialogs before moving on
+        self._check_no_visible_dialogs()
         nxt_button = self.main_window.select_single('GtkButton', name='next')
         nxt_button.click()
 
@@ -134,6 +142,7 @@
                          the tests to work for any language.
 
         """
+
         self._update_current_step('stepLanguage')
         self._check_navigation_buttons()
         #first check pageTitle visible and correct if label given
@@ -159,37 +168,24 @@
                             "doesn't contain any text")
 
         if lang:
+            if lang == 'English':
+                self.english_install = True
             item = treeview.select_item(lang)
             language = item
         else:
             language = welcome_page.get_random_language()
-        if language == 'English':
-            self.english_install = True
+            if language == 'English':
+                self.english_install = True
         welcome_page.select_language(language)
 
         self.assertThat(language.selected, Equals(True))
         ##Test release notes label is visible
         logger.debug("Checking the release_notes_label")
+        self.check_visible_object_with_label('release_notes_label')
         release_notes_label = welcome_page.select_single(
-            'GtkLabel', BuilderName='release_notes_label')
-        self.expectThat(release_notes_label.visible, Equals(True),
-                        "[Page:'{0}'] Release notes label was not visible"
-                        .format(self.current_step))
-        self.expectThat(release_notes_label.label, NotEquals(u''),
-                        "[Page:'{0}'] Release notes label did not contain "
-                        "any text".format(self.current_step))
-        self.expectIsInstance(release_notes_label.label, str,
-                              "[Page:'{0}'] Expected release notes label to "
-                              "be unicode but it wasn't")
+            BuilderName='release_notes_label')
         self.pointing_device.move_to_object(release_notes_label)
         self._update_page_titles()
-        if self.english_install:
-            #if english install check english values
-            self.eng_config = eng_label_values.stepLanguage
-            self.expectThat(release_notes_label.label,
-                            Equals(self.eng_config['release_notes_label']))
-            self.expectThat(self.current_page_title,
-                            Equals(self.eng_config['page_title']))
         self._check_page_titles()
         self._check_navigation_buttons()
 
@@ -230,25 +226,7 @@
 
         objList = ['prepare_best_results', 'prepare_foss_disclaimer',
                    'prepare_download_updates', 'prepare_nonfree_software']
-        for i in objList:
-            logging.debug("Running checks on {0} object".format(i))
-            obj = preparing_page.select_single(BuilderName=i)
-            self.expectThat(obj.visible, Equals(True),
-                            "[Page:'{0}'] Expected {1} object to be "
-                            "visible but it wasn't"
-                            .format(self.current_step, obj.name))
-            self.expectThat(obj.label, NotEquals(u''),
-                            "[Page:'{0}'] Expected {1} objects label value "
-                            "to contain text but it didn't"
-                            .format(self.current_step, obj.name))
-            self.expectIsInstance(obj.label, str,
-                                  "[Page:'{0}'] Expected {1} objects label "
-                                  "value to be unicode but it wasn't"
-                                  .format(self.current_step, obj.name))
-            if self.english_install:
-                #if english install check english values
-                self.eng_config = eng_label_values.stepPrepare
-                self.expectThat(obj.label, Equals(self.eng_config[i]))
+        self.check_visible_object_with_label(objList)
 
         if updates:
             logger.debug("Selecting install updates")
@@ -272,12 +250,10 @@
                                        visible=powerSource)
 
         self._check_page_titles()
-        if self.english_install:
-            self.expectThat(self.current_page_title,
-                            Equals(self.eng_config['page_title']))
         self._check_navigation_buttons()
 
-    def edubuntu_addon_window_tests(self, ):
+    def edubuntu_addon_window_tests(self, unity=False,
+                                    gnome=False, ltsp=False):
         """
         Run Page tests for edubuntu addon page
         """
@@ -289,30 +265,27 @@
         page_objects = ['fallback_install', 'description', 'fallback_title',
                         'fallback_description', 'ltsp_install', 'ltsp_title',
                         'ltsp_description', 'ltsp_interface_label']
-
-        for i in page_objects:
-            obj = add_on_page.select_single(BuilderName=i)
-            self.expectThat(obj.visible, Equals(True),
-                            "[Page:'{0}'] Expected {1} object to be visible "
-                            "but it wasn't"
-                            .format(self.current_step, obj.name))
-            self.expectThat(obj.label, NotEquals(u''),
-                            "[Page:'{0}'] Expected {1} objects label value "
-                            "to contain text but it didn't"
-                            .format(self.current_step, obj.name))
-            self.expectIsInstance(obj.label, str,
-                                  "[Page:'{0}'] Expected {1} objects label "
-                                  "value to be unicode but it wasn't"
-                                  .format(self.current_step, obj.name))
-            #if self.english_install:
-            #    #if english install check english values
-            #    self.eng_config = eng_label_values.stepPrepare
-            #    self.expectThat(obj.label, Equals(self.eng_config[i]))
-            #TODO: provide option to select different desktop
+        self.check_visible_object_with_label(page_objects)
+
+        env = None
+        if unity:
+            logger.debug('Using default Unity env...')
+            pass
+        elif gnome:
+            logger.debug("Using gnome fallback env")
+            env = 'fallback_install'
+        elif ltsp:
+            logger.debug('Using LTSP env')
+            env = 'ltsp_install'
+        else:
+            items = [None, 'fallback_install', 'ltsp_install']
+            env = random.choice(items)
+
+        if env:
+            choice = add_on_page.select_single(BuilderName=env)
+            self.pointing_device.click_object(choice)
+
         self._check_page_titles()
-        #if self.english_install:
-        #    self.expectThat(self.current_page_title,
-        #                    Equals(self.eng_config['page_title']))
         self._check_navigation_buttons()
 
     def edubuntu_packages_window_tests(self, ):
@@ -322,32 +295,8 @@
         self._update_current_step('edubuntu-packages_window')
         self._check_navigation_buttons()
         self._update_page_titles()
-        packages_page = self.main_window.select_single(
-            'GtkVBox', BuilderName='edubuntu-packages_window')
-        description = packages_page.select_single(
-            'GtkLabel', BuilderName='description')
-        self.expectThat(description.visible, Equals(True),
-                        "[Page:'{0}'] Expected {1} object to be visible but "
-                        "it wasn't"
-                        .format(self.current_step, description.name))
-        self.expectThat(description.label, NotEquals(u''),
-                        "[Page:'{0}'] Expected {1} objects label value to "
-                        "contain text but it didn't"
-                        .format(self.current_step, description.name))
-        self.expectIsInstance(description.label, str,
-                              "[Page:'{0}'] Expected {1} objects label "
-                              "value to be unicode but it wasn't"
-                              .format(self.current_step, description.name))
-        #if self.english_install:
-            #    #if english install check english values
-            #    self.eng_config = eng_label_values.stepPrepare
-            #    self.expectThat(obj.label, Equals(self.eng_config[i]))
-            #TODO: provide option to select different packages from tree view
-
+        self.check_visible_object_with_label('description')
         self._check_page_titles()
-        #if self.english_install:
-        #    self.expectThat(self.current_page_title,
-        #                    Equals(self.eng_config['page_title']))
         self._check_navigation_buttons()
 
     def installation_type_page_tests(self, default=False, lvm=False,
@@ -392,7 +341,9 @@
 
             config = custom_install
             option_name = 'custom_partitioning'
-        self._options_tests(config.visible_options, config.hidden_options)
+
+        self.check_visible_object_with_label(config.visible_options)
+        self.check_hidden_object_with_label(config.hidden_options)
         install_type_page = self.main_window.select_single(
             'GtkAlignment', BuilderName='stepPartAsk')
         if option_name:
@@ -400,10 +351,6 @@
             self.pointing_device.click_object(obj)
 
         self._check_page_titles()
-        if self.english_install:
-            self.expectThat(self.current_page_title,
-                            Equals(self.eng_config['page_title']))
-
         self._check_navigation_buttons()
 
     def lvm_crypto_page_tests(self, crypto_password):
@@ -426,31 +373,10 @@
         items = ['verified_crypto_label', 'crypto_label', 'crypto_description',
                  'crypto_warning', 'crypto_extra_label', 'crypto_extra_time',
                  'crypto_description_2', 'crypto_overwrite_space']
-        for i in items:
-            item = crypto_page.select_single(BuilderName=i)
-            self.expectThat(item.visible, Equals(True),
-                            "[Page:'{0}'] Expected {1} object to be visible "
-                            "but it wasn't"
-                            .format(self.current_step, item.name))
-            self.expectThat(item.label, NotEquals(u''),
-                            "[Page:'{0}'] Expected {1} objects label value "
-                            "to contain text but it didn't"
-                            .format(self.current_step, item.name))
-            self.expectIsInstance(item.label, str,
-                                  "[Page:'{0}'] Expected {1} objects label "
-                                  "value to be unicode but it wasn't"
-                                  .format(self.current_step, item.name))
-            if self.english_install:
-                #if english install check english values
-                self.eng_config = eng_label_values.stepPartCrypto
-                self.expectThat(item.label, Equals(self.eng_config[i]))
+        self.check_visible_object_with_label(items)
 
         crypto_page.enter_crypto_phrase(crypto_password)
         self._check_page_titles()
-        if self.english_install:
-            self.expectThat(self.current_page_title,
-                            Equals(self.eng_config['page_title']))
-
         self._check_navigation_buttons()
 
     def custom_partition_page_tests(self, part_config=None):
@@ -542,9 +468,6 @@
         location = ['London', 'Paris', 'Madrid', 'Algiers']
         if self.english_install:
             location_page.select_location('London')
-            self.eng_config = eng_label_values.stepLocation
-            self.expectThat(self.current_page_title,
-                            Equals(self.eng_config['page_title']))
         else:
             location_page.select_location(random.choice(location))
         self._check_page_titles()
@@ -583,12 +506,9 @@
         entry = keyboard_page.select_single('GtkEntry')
         with self.keyboard.focused_type(entry) as kb:
             kb.type(u'Testing keyboard layout')
-            # TODO: only test the entry value if we are using english install
-            #message = "Expected {0} (the length of the keyboard entry text) "
-            #     " to be {1}"
-            #     .format(len(entry.text), len(u'Testing keyboard layout'))
-            #self.expectThat(len(entry.text), Equals(
-            #   len(u'Testing keyboard layout')))
+            # only test the entry value if we are using english install
+            if self.english_install:
+                self.expectThat(entry.text, Equals(u'Testing keyboard layout'))
             self.expectThat(entry.text, NotEquals(u''),
                             "[Page:'{0}'] Expected Entry to contain text "
                             "after typing but it didn't"
@@ -599,11 +519,6 @@
                                   .format(self.current_step))
         # TODO: Test detecting keyboard layout
         self._check_page_titles()
-        if self.english_install:
-            self.eng_config = eng_label_values.stepKeyboardConf
-            self.expectThat(self.current_page_title, Equals(
-                self.eng_config['page_title']))
-
         self._check_navigation_buttons(continue_button=True, back_button=True,
                                        quit_button=False, skip_button=False)
 
@@ -634,24 +549,7 @@
                    'verified_password_label', 'hostname_extra_label'
                    ]
         logger.debug("checking user info page objects ......")
-        for i in objects:
-            obj = user_info_page.select_single('GtkLabel', name=i)
-            self.expectThat(obj.visible, Equals(True),
-                            "[Page:'{0}'] Expected {1} object to be visible "
-                            "but it wasn't"
-                            .format(self.current_step, obj.name))
-            self.expectThat(obj.label, NotEquals(u''),
-                            "[Page:'{0}'] Expected {1} objects label value to "
-                            "contain text but it didn't"
-                            .format(self.current_step, obj.name))
-            self.expectIsInstance(obj.label, str,
-                                  "[Page:'{0}'] Expected {1} objects label "
-                                  "value to be unicode but it wasn't"
-                                  .format(self.current_step, obj.name))
-            if self.english_install:
-                #if english install check english values
-                self.eng_config = eng_label_values.stepUserInfo
-                self.expectThat(obj.label, Equals(self.eng_config[i]))
+        self.check_visible_object_with_label(objects)
 
         user_info_page.create_user(username, pwd)
         #TODO: get these working
@@ -661,29 +559,180 @@
             user_info_page.set_auto_login()
 
         self._check_page_titles()
-        if self.english_install:
-            self.expectThat(self.current_page_title,
-                            Equals(self.eng_config['page_title']))
-
         self._check_navigation_buttons(continue_button=True, back_button=True,
                                        quit_button=False, skip_button=False)
 
     def ubuntu_one_page_tests(self, ):
-        #self._update_current_step('stepUserInfo')
+        self._update_current_step('stepUbuntuOne')
         self._check_navigation_buttons(continue_button=True, back_button=True,
                                        quit_button=False, skip_button=True)
         logger.debug("run_ubuntu_one_page_tests()")
+        #uOnePage = self.main_window.select_single(BuilderName='stepUbuntuOne')
+        page_objects = ['u1_about_label', 'cloud_label', 'music_label',
+                        'photos_label', 'apps_label', 'u1_existing_account',
+                        'u1_new_account', 'u1_explain_email_2',
+                        'u1_explain_email', 'u1_terms',
+                        'password_mismatch', 'u1_ask_name_pass',
+                        'u1_ask_email', 'u1_no_internet']
+        self.check_visible_object_with_label(page_objects)
+        # XXX: we currently can't test signing in as it is yet to possible
+        # to set ubiquity to use a staging server for testing.
         skip_button = self.main_window.select_single('GtkButton', name='skip')
         self.pointing_device.click_object(skip_button)
-        #TODO: add checks to the U1 page
+        #lets just sleep a little to wait for progress page as we
+        # can't wait on the page_title
+        time.sleep(5)
 
     def progress_page_tests(self, ):
-        # TODO: move here from emulator and use process manager to check window
-        # stack doesn't change during the progress stage and if a dialog
-        # becomes top of stack we get window title to work outwhich one.
-        # Currently polling on dbus for two specific dialogs is really horrible
-        # for the logs and test design so need to find a cleaner way.
-        pass
+        ''' Runs the test for the installation progress page
+
+            This method tracks the current progress of the install
+            by using the fraction property of the progress bar
+            to assertain the percentage complete.
+
+        '''
+        logger.debug("run_install_progress_page_tests()")
+        #We cant assert page title here as its an external html page
+        #Maybe try assert WebKitWebView is visible
+        webkitwindow = self.main_window.select_single(
+            'GtkScrolledWindow', name='webkit_scrolled_window'
+        )
+        self.expectThat(webkitwindow.visible, Equals(True))
+
+        progress_bar = self.main_window.select_single(
+            'GtkProgressBar', name='install_progress')
+
+        #Copying files progress bar
+        self._track_install_progress()
+
+        self.assertThat(progress_bar.fraction, Eventually(
+            Equals(0.0), timeout=120))
+        #And now the install progress bar
+        self._track_install_progress()
+
+    def check_visible_object_with_label(self, visible_obj):
+        """Check an visible objects label and visible properties,
+
+        :param visible_obj: Accepts either a objects name property or
+                            a list of names
+        ..note:: If english installation this function will also test the
+                 english label value which is retrieved from the
+                 generated english_config.ini file
+        """
+        if isinstance(visible_obj, list):
+            for item in visible_obj:
+                self._check_object(item)
+            return
+        if isinstance(visible_obj, str):
+            self._check_object(visible_obj)
+            return
+        raise ValueError(
+            "Object name must either be a string or list of strings")
+
+    def check_hidden_object_with_label(self, hidden_obj):
+        """Check an hidden objects label and visible properties,
+
+        :param hidden_obj: Accepts either a objects name property or
+                            a list of names
+        """
+        if isinstance(hidden_obj, list):
+            for item in hidden_obj:
+                self._check_object(item, False)
+            return
+        if isinstance(hidden_obj, str):
+            self._check_object(hidden_obj, False)
+            return
+        raise ValueError(
+            "Object name must either be a string or list of strings")
+
+    def _check_object(self, obj_name, obj_visible=True):
+        logger.debug("Checking {0} object.......".format(obj_name))
+        #select current page object
+        page = self.main_window.select_single(BuilderName=self.current_step)
+        #select object
+        page_object = page.select_single(BuilderName=obj_name)
+        if obj_visible:
+            visible_message = "[Page:'{0}'] Expected {1} object to be " \
+                              "visible but it wasn't".format(self.current_step,
+                                                             page_object.name)
+        else:
+            visible_message = "[Page:'{0}'] Expected {1} object to not be " \
+                              "visible but it was!".format(self.current_step,
+                                                           page_object.name)
+        self.expectThat(page_object.visible, Equals(obj_visible),
+                        visible_message)
+        self.expectThat(page_object.label, NotEquals(u''),
+                        "[Page:'{0}'] Expected {1} objects label value to "
+                        "contain text but it didn't"
+                        .format(self.current_step, page_object.name))
+        self.expectIsInstance(page_object.label, str,
+                              "[Page:'{0}'] Expected {1} objects label "
+                              "value to be unicode but it wasn't"
+                              .format(self.current_step, page_object.name))
+        #we only want to test visible english values, hidden ones don't matter
+        if (self.current_step in self.english_config) and obj_visible:
+            if self.english_install and (
+                    obj_name in self.english_config[self.current_step]):
+                logger.debug(
+                    "Checking {0} object's english label value....".format(
+                        obj_name))
+                #if english install check english values
+                self.expectThat(page_object.label, Equals(
+                    self.english_config[self.current_step][obj_name]))
+
+    def _track_install_progress(self, ):
+        '''Gets the value of the fraction property of the progress bar
+
+            so we can see when the progress bar is complete
+
+        '''
+        logger.debug("_track_install_progress_bar()")
+        progress_bar = self.main_window.select_single(
+            'GtkProgressBar', name='install_progress'
+        )
+        progress = 0.0
+        complete = 1.0
+        logger.debug('Percentage complete "{0:.0f}%"'.format(progress * 100))
+        while progress < complete:
+            #keep updating fraction value
+            progress = progress_bar.fraction
+            # lets sleep for longer at early stages then
+            # reduce nearer to complete
+            if progress < 0.5:
+                time.sleep(5)
+            elif progress < 0.7:
+                time.sleep(3)
+            elif progress < 0.8:
+                time.sleep(1)
+            else:
+                pass
+
+            logger.debug('Percentage complete "{0:.0f}%"'
+                         .format(progress * 100))
+            #check for install errors while waiting
+            self._check_no_visible_dialogs()
+            try:
+                grub_dialog = self.main_window.get_dialog('GtkMessageDialog')
+                if grub_dialog.visible:
+                    logger.error("The Grub installation failed dialog "
+                                 "appeared :-(")
+                    self.assertThat(grub_dialog.visible, Equals(True),
+                                    "The Grub installation failed")
+                    progress = 1.0
+            except Exception:
+                pass
+
+    def _check_no_visible_dialogs(self):
+        dialogs = ['warning_dialog', 'crash_dialog',
+                   'bootloader_fail_dialog', 'ubi_question_dialog']
+        # check each dialog is not visible
+        for dialog in dialogs:
+            logger.debug("Checking {0} dialog hasn't "
+                         "appeared.......".format(dialog))
+            dlg = self.main_window.get_dialog(
+                'GtkDialog', BuilderName=dialog
+            )
+            self.assertThat(dlg.visible, Equals(False))
 
     def _add_new_partition(self, ):
         """ adds a new partition """
@@ -807,6 +856,14 @@
         current_page_title = self.main_window.select_single(
             'GtkLabel',
             BuilderName='page_title')
+        if self.current_step in self.english_config:
+            if self.english_install and (
+                    'page_title' in self.english_config[self.current_step]):
+                #if english install check english values
+                self.expectThat(current_page_title.label, Equals(
+                    self.english_config[self.current_step]['page_title']))
+        #also lets check it changed from the previous page
+
         message_one = "Expected %s page title '%s' to not equal the "\
             "previous %s page title '%s' but it does" % (
                 self.current_step, self.current_page_title,
@@ -870,49 +927,6 @@
                             "visible but it was"
                             .format(self.current_step, stateboxName))
 
-    def _options_tests(self, visible=[], hidden=[]):
-
-        install_type_page = self.main_window.select_single(
-            'GtkAlignment',
-            BuilderName='stepPartAsk')
-
-        for option in visible:
-            logger.info("selecting Visible object'{0}'".format(option))
-            opt = install_type_page.select_single(BuilderName=option)
-            self.expectThat(opt.visible, Equals(True),
-                            "[Page:'{0}'] Expected {1} object to be visible "
-                            "but it wasn't"
-                            .format(self.current_step, opt.name))
-            self.expectThat(opt.label, NotEquals(u''),
-                            "[Page:'{0}'] Expected {1} objects label value to "
-                            "contain text but it didn't"
-                            .format(self.current_step, opt.name))
-            self.expectIsInstance(opt.label, str,
-                                  "[Page:'{0}'] Expected {1} objects label "
-                                  "value to be unicode but it wasn't"
-                                  .format(self.current_step, opt.name))
-            if self.english_install:
-                #if english install check english values
-                self.eng_config = eng_label_values.stepPartAsk
-                self.expectThat(opt.label, Equals(self.eng_config[option]))
-
-        for option in hidden:
-            logger.info("Selecting hidden object '{0}'".format(option))
-
-            opt = install_type_page.select_single(BuilderName=option)
-            self.expectThat(opt.visible, Equals(False),
-                            "[Page:'{0}'] Expected {1} object to be not "
-                            "visible but it was"
-                            .format(self.current_step, opt.name))
-            self.expectThat(opt.label, NotEquals(u''),
-                            "[Page:'{0}'] Expected {1} objects label value to "
-                            "contain text but it didn't"
-                            .format(self.current_step, opt.name))
-            self.expectIsInstance(opt.label, str,
-                                  "[Page:'{0}'] Expected {1} objects label "
-                                  "value to be unicode but it wasn't"
-                                  .format(self.current_step, opt.name))
-
     def _select_install_type(self, install_type):
         pass
 

=== modified file 'autopilot/ubiquity_autopilot_tests/tests/test_custom_install.py'
--- autopilot/ubiquity_autopilot_tests/tests/test_custom_install.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/tests/test_custom_install.py	2013-11-29 17:06:55 +0000
@@ -63,7 +63,7 @@
         else:
             self.go_to_progress_page()
 
-        self.main_window.run_install_progress_page_tests()
+        self.progress_page_tests()
         self.assertThat(lambda: self.app.select_single(
             'GtkDialog',
             name='finished_dialog').visible,

=== modified file 'autopilot/ubiquity_autopilot_tests/tests/test_english_default.py'
--- autopilot/ubiquity_autopilot_tests/tests/test_english_default.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/tests/test_english_default.py	2013-11-29 17:06:55 +0000
@@ -35,7 +35,7 @@
         self.preparing_page_tests()
         self.go_to_next_page()
         if flavor == 'Edubuntu':
-            self.edubuntu_addon_window_tests()
+            self.edubuntu_addon_window_tests(gnome=True)
             self.go_to_next_page()
             self.edubuntu_packages_window_tests()
             self.go_to_next_page()
@@ -53,7 +53,7 @@
         else:
             self.go_to_progress_page()
 
-        self.main_window.run_install_progress_page_tests()
+        self.progress_page_tests()
         self.assertThat(lambda: self.app.select_single(
             'GtkDialog',
             name='finished_dialog').visible,

=== modified file 'autopilot/ubiquity_autopilot_tests/tests/test_english_encrypt_lvm.py'
--- autopilot/ubiquity_autopilot_tests/tests/test_english_encrypt_lvm.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/tests/test_english_encrypt_lvm.py	2013-11-29 17:06:55 +0000
@@ -54,7 +54,7 @@
         else:
             self.go_to_progress_page()
 
-        self.main_window.run_install_progress_page_tests()
+        self.progress_page_tests()
         self.assertThat(lambda: self.app.select_single(
             'GtkDialog',
             name='finished_dialog').visible,

=== modified file 'autopilot/ubiquity_autopilot_tests/tests/test_english_lvm.py'
--- autopilot/ubiquity_autopilot_tests/tests/test_english_lvm.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/tests/test_english_lvm.py	2013-11-29 17:06:55 +0000
@@ -52,7 +52,7 @@
         else:
             self.go_to_progress_page()
 
-        self.main_window.run_install_progress_page_tests()
+        self.progress_page_tests()
         self.assertThat(lambda: self.app.select_single(
             'GtkDialog',
             name='finished_dialog').visible,

=== modified file 'autopilot/ubiquity_autopilot_tests/tests/test_nonenglish_default.py'
--- autopilot/ubiquity_autopilot_tests/tests/test_nonenglish_default.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/tests/test_nonenglish_default.py	2013-11-29 17:06:55 +0000
@@ -35,7 +35,7 @@
         self.preparing_page_tests()
         self.go_to_next_page()
         if flavor == 'Edubuntu':
-            self.edubuntu_addon_window_tests()
+            self.edubuntu_addon_window_tests(ltsp=True)
             self.go_to_next_page()
             self.edubuntu_packages_window_tests()
             self.go_to_next_page()
@@ -53,7 +53,7 @@
         else:
             self.go_to_progress_page()
 
-        self.main_window.run_install_progress_page_tests()
+        self.progress_page_tests()
         self.assertThat(lambda: self.app.select_single(
             'GtkDialog',
             name='finished_dialog').visible,

=== modified file 'autopilot/ubiquity_autopilot_tests/tests/test_nonenglish_encrypt_lvm.py'
--- autopilot/ubiquity_autopilot_tests/tests/test_nonenglish_encrypt_lvm.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/tests/test_nonenglish_encrypt_lvm.py	2013-11-29 17:06:55 +0000
@@ -55,7 +55,7 @@
         else:
             self.go_to_progress_page()
 
-        self.main_window.run_install_progress_page_tests()
+        self.progress_page_tests()
         self.assertThat(lambda: self.app.select_single(
             'GtkDialog',
             name='finished_dialog').visible,

=== modified file 'autopilot/ubiquity_autopilot_tests/tests/test_nonenglish_lvm.py'
--- autopilot/ubiquity_autopilot_tests/tests/test_nonenglish_lvm.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/tests/test_nonenglish_lvm.py	2013-11-29 17:06:55 +0000
@@ -52,7 +52,7 @@
         else:
             self.go_to_progress_page()
 
-        self.main_window.run_install_progress_page_tests()
+        self.progress_page_tests()
         self.assertThat(lambda: self.app.select_single(
             'GtkDialog',
             name='finished_dialog').visible,

=== removed directory 'autopilot/ubiquity_autopilot_tests/unittests'
=== removed file 'autopilot/ubiquity_autopilot_tests/unittests/__init__.py'
=== removed file 'autopilot/ubiquity_autopilot_tests/unittests/test_expects.py'
--- autopilot/ubiquity_autopilot_tests/unittests/test_expects.py	2013-11-01 19:36:31 +0000
+++ autopilot/ubiquity_autopilot_tests/unittests/test_expects.py	1970-01-01 00:00:00 +0000
@@ -1,12 +0,0 @@
-__author__ = 'dan'
-import unittest
-from testtools.testcase import TestCase
-
-
-class ExpectTestCase(TestCase):
-    def test_something(self):
-        self.assertEqual(True, True)
-
-
-if __name__ == '__main__':
-    unittest.main()

=== removed file 'autopilot/ubiquity_autopilot_tests/unittests/test_matchers.py'
--- autopilot/ubiquity_autopilot_tests/unittests/test_matchers.py	2013-11-19 09:07:08 +0000
+++ autopilot/ubiquity_autopilot_tests/unittests/test_matchers.py	1970-01-01 00:00:00 +0000
@@ -1,14 +0,0 @@
-__author__ = 'dan'
-
-import unittest
-from testtools.testcase import TestCase
-from testtools.matchers import Equals
-
-
-class MyTestCase(TestCase):
-
-    def test_something(self):
-        self.assertThat(True, Equals(False))
-
-if __name__ == '__main__':
-    unittest.main()