Merge lp:~sil2100/unity/fix-949448-5.0 into lp:unity

[Łukasz Zemczak]

Backported andyrock's fix from lp:unity/6.0 - Unmute launcher.

This branch needs to be tested. I see no other dependency changes, but I cannot get it to work with orca somehow. Could anyone else check it? Maybe I'm doing something wrong.

Original MRQ:

Copy-pasted from the original andyrock's MRQ for 6.0:
https://code.launchpad.net/~andyrock/unity/fix-949448/+merge/102860

== Problem ==
Launcher is silent to screen reader users.

== Fix ==
Fix a couple of regressions. Alan Bell confirmed the fix for the launcher.

== Test ==
Not sure how we could test it.

=== modified file 'launcher/BamfLauncherIcon.cpp'
=== modified file 'launcher/LauncherController.cpp'
=== modified file 'plugins/unityshell/src/unitya11y.cpp'
=== added directory 'tests/autopilot/autopilot'
=== added directory 'tests/autopilot/autopilot/emulators'
=== added file 'tests/autopilot/autopilot/emulators/bamf.py.OTHER'
--- tests/autopilot/autopilot/emulators/bamf.py.OTHER	1970-01-01 00:00:00 +0000
+++ tests/autopilot/autopilot/emulators/bamf.py.OTHER	2012-05-23 10:30:27 +0000
@@ -0,0 +1,411 @@
+# Copyright 2011 Canonical
+# Author: Thomi Richards
+#
+# 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.
+
+"Various classes for interacting with BAMF."
+
+import dbus
+import dbus.glib
+import gio
+import gobject
+import os
+from Xlib import display, X, protocol
+from gtk import gdk
+
+from autopilot.emulators.dbus_handler import session_bus
+
+__all__ = [
+    "Bamf",
+    "BamfApplication",
+    "BamfWindow",
+    ]
+
+_BAMF_BUS_NAME = 'org.ayatana.bamf'
+_X_DISPLAY = display.Display()
+
+
+def _filter_user_visible(win):
+    """Filter out non-user-visible objects.
+
+    In some cases the DBus method we need to call hasn't been registered yet,
+    in which case we do the safe thing and return False.
+
+    """
+    try:
+        return win.user_visible
+    except dbus.DBusException:
+        return False
+
+
+class Bamf(object):
+    """High-level class for interacting with Bamf from within a test.
+
+    Use this class to inspect the state of running applications and open
+    windows.
+
+    """
+
+    def __init__(self):
+        matcher_path = '/org/ayatana/bamf/matcher'
+        self.matcher_interface_name = 'org.ayatana.bamf.matcher'
+        self.matcher_proxy = session_bus.get_object(_BAMF_BUS_NAME, matcher_path)
+        self.matcher_interface = dbus.Interface(self.matcher_proxy, self.matcher_interface_name)
+
+    def get_running_applications(self, user_visible_only=True):
+        """Get a list of the currently running applications.
+
+        If user_visible_only is True (the default), only applications
+        visible to the user in the switcher will be returned.
+
+        """
+        apps = [BamfApplication(p) for p in self.matcher_interface.RunningApplications()]
+        if user_visible_only:
+            return filter(_filter_user_visible, apps)
+        return apps
+
+    def get_running_applications_by_desktop_file(self, desktop_file):
+        """Return a list of applications that have the desktop file 'desktop_file'`.
+
+        This method may return an empty list, if no applications
+        are found with the specified desktop file.
+
+        """
+        return [a for a in self.get_running_applications() if a.desktop_file == desktop_file]
+
+    def get_application_by_xid(self, xid):
+        """Return the application that has a child with the requested xid or None."""
+
+        app_path = self.matcher_interface.ApplicationForXid(xid)
+        if len(app_path):
+            return BamfApplication(app_path)
+        return None
+
+    def get_open_windows(self, user_visible_only=True):
+        """Get a list of currently open windows.
+
+        If user_visible_only is True (the default), only applications
+        visible to the user in the switcher will be returned.
+
+        The result is sorted to be in stacking order.
+
+        """
+
+        windows = [BamfWindow(w) for w in self.matcher_interface.WindowStackForMonitor(-1)]
+        if user_visible_only:
+            windows = filter(_filter_user_visible, windows)
+        # Now sort on stacking order.
+        return reversed(windows)
+
+    def get_window_by_xid(self, xid):
+        """Get the BamfWindow that matches the provided 'xid'."""
+        windows = [BamfWindow(w) for w in self.matcher_interface.WindowPaths() if BamfWindow(w).x_id == xid]
+        return windows[0] if windows else None
+
+    def wait_until_application_is_running(self, desktop_file, timeout):
+        """Wait until a given application is running.
+
+        'desktop_file' is the name of the application desktop file.
+        'timeout' is the maximum time to wait, in seconds. If set to
+        something less than 0, this method will wait forever.
+
+        This method returns true once the application is found, or false
+        if the application was not found until the timeout was reached.
+        """
+        desktop_file = os.path.split(desktop_file)[1]
+        # python workaround since you can't assign to variables in the enclosing scope:
+        # see on_timeout_reached below...
+        found_app = [True]
+
+        # maybe the app is running already?
+        if len(self.get_running_applications_by_desktop_file(desktop_file)) == 0:
+            wait_forever = timeout < 0
+            gobject_loop = gobject.MainLoop()
+
+            # No, so define a callback to watch the ViewOpened signal:
+            def on_view_added(bamf_path, name):
+                if bamf_path.split('/')[-1].startswith('application'):
+                    app = BamfApplication(bamf_path)
+                    if desktop_file == os.path.split(app.desktop_file)[1]:
+                        gobject_loop.quit()
+
+            # ...and one for when the user-defined timeout has been reached:
+            def on_timeout_reached():
+                gobject_loop.quit()
+                found_app[0] = False
+                return False
+
+            # need a timeout? if so, connect it:
+            if not wait_forever:
+                gobject.timeout_add(timeout * 1000, on_timeout_reached)
+            # connect signal handler:
+            session_bus.add_signal_receiver(on_view_added, 'ViewOpened')
+            # pump the gobject main loop until either the correct signal is emitted, or the
+            # timeout happens.
+            gobject_loop.run()
+
+        return found_app[0]
+
+    def launch_application(self, desktop_file, files=[], wait=True):
+        """Launch an application by specifying a desktop file.
+
+        `files` is a list of files to pass to the application. Not all apps support this.
+
+        If `wait` is True, this method will block until the application has launched.
+
+        Returns the Gobject process object. if wait is True (the default),
+        this method will not return until an instance of this application
+        appears in the BAMF application list.
+        """
+        if type(files) is not list:
+            raise TypeError("files must be a list.")
+        proc = gio.unix.DesktopAppInfo(desktop_file)
+        proc.launch_uris(files)
+        if wait:
+            self.wait_until_application_is_running(desktop_file, -1)
+        return proc
+
+
+class BamfApplication(object):
+    """Represents an application, with information as returned by Bamf.
+
+    Don't instantiate this class yourself. instead, use the methods as
+    provided by the Bamf class.
+
+    """
+    def __init__(self, bamf_app_path):
+        self.bamf_app_path = bamf_app_path
+        try:
+            self._app_proxy = session_bus.get_object(_BAMF_BUS_NAME, bamf_app_path)
+            self._view_iface = dbus.Interface(self._app_proxy, 'org.ayatana.bamf.view')
+            self._app_iface = dbus.Interface(self._app_proxy, 'org.ayatana.bamf.application')
+        except dbus.DBusException, e:
+            e.message += 'bamf_app_path=%r' % (bamf_app_path)
+            raise
+
+    @property
+    def desktop_file(self):
+        """Get the application desktop file"""
+        return os.path.split(self._app_iface.DesktopFile())[1]
+
+    @property
+    def name(self):
+        """Get the application name.
+
+        Note: This may change according to the current locale. If you want a unique
+        string to match applications against, use the desktop_file instead.
+
+        """
+        return self._view_iface.Name()
+
+    @property
+    def icon(self):
+        """Get the application icon."""
+        return self._view_iface.Icon()
+
+    @property
+    def is_active(self):
+        """Is the application active (i.e.- has keyboard focus)?"""
+        return self._view_iface.IsActive()
+
+    @property
+    def is_urgent(self):
+        """Is the application currently signalling urgency?"""
+        return self._view_iface.IsUrgent()
+
+    @property
+    def user_visible(self):
+        """Is this application visible to the user?
+
+        Some applications (such as the panel) are hidden to the user but will
+        still be returned by bamf.
+
+        """
+        return self._view_iface.UserVisible()
+
+    def get_windows(self):
+        """Get a list of the application windows."""
+        return [BamfWindow(w) for w in self._view_iface.Children()]
+
+    def __repr__(self):
+        return "<BamfApplication '%s'>" % (self.name)
+
+
+class BamfWindow(object):
+    """Represents an application window, as returned by Bamf.
+
+    Don't instantiate this class yourself. Instead, use the appropriate methods
+    in BamfApplication.
+
+    """
+    def __init__(self, window_path):
+        self._bamf_win_path = window_path
+        self._app_proxy = session_bus.get_object(_BAMF_BUS_NAME, window_path)
+        self._window_iface = dbus.Interface(self._app_proxy, 'org.ayatana.bamf.window')
+        self._view_iface = dbus.Interface(self._app_proxy, 'org.ayatana.bamf.view')
+
+        self._xid = int(self._window_iface.GetXid())
+        self._x_root_win = _X_DISPLAY.screen().root
+        self._x_win = _X_DISPLAY.create_resource_object('window', self._xid)
+
+    @property
+    def x_id(self):
+        """Get the X11 Window Id."""
+        return self._xid
+
+    @property
+    def x_win(self):
+        """Get the X11 window object of the underlying window."""
+        return self._x_win
+
+    @property
+    def name(self):
+        """Get the window name.
+
+        Note: This may change according to the current locale. If you want a unique
+        string to match windows against, use the x_id instead.
+
+        """
+        return self._view_iface.Name()
+
+    @property
+    def title(self):
+        """Get the window title.
+
+        This may be different from the application name.
+
+        Note that this may change depending on the current locale.
+
+        """
+        return self._getProperty('_NET_WM_NAME')
+
+    @property
+    def geometry(self):
+        """Get the geometry for this window.
+
+        Returns a tuple containing (x, y, width, height).
+
+        """
+        # FIXME: We need to use the gdk window here to get the real coordinates
+        geometry = self._x_win.get_geometry()
+        origin = gdk.window_foreign_new(self._xid).get_origin()
+        return (origin[0], origin[1], geometry.width, geometry.height)
+
+    @property
+    def is_maximized(self):
+        """Is the window maximized?
+
+        Maximized in this case means both maximized
+        vertically and horizontally. If a window is only maximized in one
+        direction it is not considered maximized.
+
+        """
+        win_state = self._get_window_states()
+        return '_NET_WM_STATE_MAXIMIZED_VERT' in win_state and \
+            '_NET_WM_STATE_MAXIMIZED_HORZ' in win_state
+
+    @property
+    def application(self):
+        """Get the application that owns this window.
+
+        This method may return None if the window does not have an associated
+        application. The 'desktop' window is one such example.
+
+        """
+        # BAMF returns a list of parents since some windows don't have an
+        # associated application. For these windows we return none.
+        parents = self._view_iface.Parents()
+        if parents:
+            return BamfApplication(parents[0])
+        else:
+            return None
+
+    @property
+    def user_visible(self):
+        """Is this window visible to the user in the switcher?"""
+        return self._view_iface.UserVisible()
+
+    @property
+    def is_hidden(self):
+        """Is this window hidden?
+
+        Windows are hidden when the 'Show Desktop' mode is activated.
+
+        """
+        win_state = self._get_window_states()
+        return '_NET_WM_STATE_HIDDEN' in win_state
+
+    @property
+    def is_focused(self):
+        """Is this window focused?"""
+        win_state = self._get_window_states()
+        return '_NET_WM_STATE_FOCUSED' in win_state
+
+    @property
+    def is_valid(self):
+        """Is this window object valid?
+
+        Invalid windows are caused by windows closing during the construction of
+        this object instance.
+
+        """
+        return not self._x_win is None
+
+    @property
+    def monitor(self):
+        """Returns the monitor to which the windows belongs to"""
+        return self._window_iface.Monitor()
+
+    @property
+    def closed(self):
+        """Returns True if the window has been closed"""
+        # This will return False when the window is closed and then removed from BUS
+        try:
+            return (self._window_iface.GetXid() != self.x_id)
+        except:
+            return True
+
+    def close(self):
+        """Close the window."""
+
+        self._setProperty('_NET_CLOSE_WINDOW', [0, 0])
+
+    def set_focus(self):
+        self._x_win.set_input_focus(X.RevertToParent, X.CurrentTime)
+        self._x_win.configure(stack_mode=X.Above)
+
+    def __repr__(self):
+        return "<BamfWindow '%s'>" % (self.title if self._x_win else str(self._xid))
+
+    def _getProperty(self, _type):
+        """Get an X11 property.
+
+        _type is a string naming the property type. win is the X11 window object.
+
+        """
+        atom = self._x_win.get_full_property(_X_DISPLAY.get_atom(_type), X.AnyPropertyType)
+        if atom:
+            return atom.value
+
+    def _setProperty(self, _type, data, mask=None):
+        if type(data) is str:
+            dataSize = 8
+        else:
+            # data length must be 5 - pad with 0's if it's short, truncate otherwise.
+            data = (data + [0] * (5 - len(data)))[:5]
+            dataSize = 32
+
+        ev = protocol.event.ClientMessage(window=self._x_win, client_type=_X_DISPLAY.get_atom(_type), data=(dataSize, data))
+
+        if not mask:
+            mask = (X.SubstructureRedirectMask | X.SubstructureNotifyMask)
+        self._x_root_win.send_event(ev, event_mask=mask)
+        _X_DISPLAY.sync()
+
+    def _get_window_states(self):
+        """Return a list of strings representing the current window state."""
+
+        _X_DISPLAY.sync()
+        return map(_X_DISPLAY.get_atom_name, self._getProperty('_NET_WM_STATE'))

=== modified file 'tests/autopilot/unity/emulators/icons.py'
=== modified file 'tests/autopilot/unity/emulators/launcher.py'
=== modified file 'tests/autopilot/unity/tests/__init__.py'
--- tests/autopilot/unity/tests/__init__.py	2012-05-16 23:02:38 +0000
+++ tests/autopilot/unity/tests/__init__.py	2012-05-23 10:30:27 +0000
@@ -122,3 +122,228 @@
         """
         set_log_severity(component, level)
 
+<<<<<<< TREE
+=======
+
+class VideoCapturedTestCase(LoggedTestCase):
+    """Video capture autopilot tests, saving the results if the test failed."""
+
+    _recording_app = '/usr/bin/recordmydesktop'
+    _recording_opts = ['--no-sound', '--no-frame', '-o',]
+
+    def setUp(self):
+        super(VideoCapturedTestCase, self).setUp()
+        global video_recording_enabled
+        if video_recording_enabled and not self._have_recording_app():
+            video_recording_enabled = False
+            logger.warning("Disabling video capture since '%s' is not present", self._recording_app)
+
+        if video_recording_enabled:
+            self._test_passed = True
+            self.addOnException(self._on_test_failed)
+            self.addCleanup(self._stop_video_capture)
+            self._start_video_capture()
+
+    def _have_recording_app(self):
+        return os.path.exists(self._recording_app)
+
+    def _start_video_capture(self):
+        args = self._get_capture_command_line()
+        self._capture_file = self._get_capture_output_file()
+        self._ensure_directory_exists_but_not_file(self._capture_file)
+        args.append(self._capture_file)
+        logger.debug("Starting: %r", args)
+        self._capture_process = Popen(args, stdout=PIPE, stderr=STDOUT)
+
+    def _stop_video_capture(self):
+        """Stop the video capture. If the test failed, save the resulting file."""
+
+        if self._test_passed:
+            # We use kill here because we don't want the recording app to start
+            # encoding the video file (since we're removing it anyway.)
+            self._capture_process.kill()
+            self._capture_process.wait()
+        else:
+            self._capture_process.terminate()
+            self._capture_process.wait()
+            if self._capture_process.returncode != 0:
+                self.addDetail('video capture log', text_content(self._capture_process.stdout.read()))
+        self._capture_process = None
+
+    def _get_capture_command_line(self):
+        return [self._recording_app] + self._recording_opts
+
+    def _get_capture_output_file(self):
+        return os.path.join(video_record_directory, '%s.ogv' % (self.shortDescription()))
+
+    def _ensure_directory_exists_but_not_file(self, file_path):
+        dirpath = os.path.dirname(file_path)
+        if not os.path.exists(dirpath):
+            os.makedirs(dirpath)
+        elif os.path.exists(file_path):
+            logger.warning("Video capture file '%s' already exists, deleting.", file_path)
+            os.remove(file_path)
+
+    def _on_test_failed(self, ex_info):
+        """Called when a test fails."""
+        self._test_passed = False
+
+
+class AutopilotTestCase(VideoCapturedTestCase, KeybindingsHelper):
+    """Wrapper around testtools.TestCase that takes care of some cleaning."""
+
+    run_test_with = GlibRunner
+
+    KNOWN_APPS = {
+        'Character Map' : {
+            'desktop-file': 'gucharmap.desktop',
+            'process-name': 'gucharmap',
+            },
+        'Calculator' : {
+            'desktop-file': 'gcalctool.desktop',
+            'process-name': 'gcalctool',
+            },
+        'Mahjongg' : {
+            'desktop-file': 'mahjongg.desktop',
+            'process-name': 'mahjongg',
+            },
+        'Remmina' : {
+            'desktop-file': 'remmina.desktop',
+            'process-name': 'remmina',
+            },
+        'System Settings' : {
+            'desktop-file': 'gnome-control-center.desktop',
+            'process-name': 'gnome-control-center',
+            },
+        'Text Editor' : {
+            'desktop-file': 'gedit.desktop',
+            'process-name': 'gedit',
+            },
+        }
+
+    def setUp(self):
+        super(AutopilotTestCase, self).setUp()
+        self.bamf = Bamf()
+        self.keyboard = Keyboard()
+        self.mouse = Mouse()
+        self.dash = Dash()
+        self.hud = Hud()
+        self.launcher = self._get_launcher_controller()
+        self.panels = self._get_panel_controller()
+        self.switcher = Switcher()
+        self.window_manager = self._get_window_manager()
+        self.workspace = WorkspaceManager()
+        self.screen_geo = ScreenGeometry()
+        self.addCleanup(self.workspace.switch_to, self.workspace.current_workspace)
+        self.addCleanup(Keyboard.cleanup)
+        self.addCleanup(Mouse.cleanup)
+
+    def start_app(self, app_name, files=[], locale=None):
+        """Start one of the known apps, and kill it on tear down.
+
+        If files is specified, start the application with the specified files.
+        If locale is specified, the locale will be set when the application is launched.
+
+        The method returns the BamfApplication instance.
+
+        """
+        if locale:
+            os.putenv("LC_ALL", locale)
+            self.addCleanup(os.unsetenv, "LC_ALL")
+            logger.info("Starting application '%s' with files %r in locale %s", app_name, files, locale)
+        else:
+            logger.info("Starting application '%s' with files %r", app_name, files)
+
+        app = self.KNOWN_APPS[app_name]
+        self.bamf.launch_application(app['desktop-file'], files)
+        apps = self.bamf.get_running_applications_by_desktop_file(app['desktop-file'])
+        self.addCleanup(call, "kill `pidof %s`" % (app['process-name']), shell=True)
+        self.assertThat(len(apps), Equals(1))
+        return apps[0]
+
+    def close_all_app(self, app_name):
+        """Close all instances of the app_name."""
+        app = self.KNOWN_APPS[app_name]
+        pids = check_output(["pidof", app['process-name']]).split()
+        if len(pids):
+            call(["kill"] + pids)
+
+    def get_app_instances(self, app_name):
+        """Get BamfApplication instances for app_name."""
+        desktop_file = self.KNOWN_APPS[app_name]['desktop-file']
+        return self.bamf.get_running_applications_by_desktop_file(desktop_file)
+
+    def app_is_running(self, app_name):
+        """Returns true if an instance of the application is running."""
+        apps = self.get_app_instances(app_name)
+        return len(apps) > 0
+
+    def call_gsettings_cmd(self, command, schema, *args):
+        """Set a desktop wide gsettings option
+
+        Using the gsettings command because there's a bug with importing
+        from gobject introspection and pygtk2 simultaneously, and the Xlib
+        keyboard layout bits are very unweildy. This seems like the best
+        solution, even a little bit brutish.
+        """
+        cmd = ['gsettings', command, schema] + list(args)
+        # strip to remove the trailing \n.
+        ret = check_output(cmd).strip()
+        time.sleep(5)
+        reset_display()
+        return ret
+
+    def set_unity_option(self, option_name, option_value):
+        """Set an option in the unity compiz plugin options.
+
+        The value will be set for the current test only.
+
+        """
+        self.set_compiz_option("unityshell", option_name, option_value)
+
+    def set_compiz_option(self, plugin_name, setting_name, setting_value):
+        """Set setting `setting_name` in compiz plugin `plugin_name` to value `setting_value`
+        for one test only.
+        """
+        old_value = self._set_compiz_option(plugin_name, setting_name, setting_value)
+        self.addCleanup(self._set_compiz_option, plugin_name, setting_name, old_value)
+        # Allow unity time to respond to the new setting.
+        time.sleep(0.5)
+
+    def _set_compiz_option(self, plugin_name, option_name, option_value):
+        logger.info("Setting compiz option '%s' in plugin '%s' to %r",
+            option_name, plugin_name, option_value)
+        plugin = Plugin(global_context, plugin_name)
+        setting = Setting(plugin, option_name)
+        old_value = setting.Value
+        setting.Value = option_value
+        global_context.Write()
+        return old_value
+
+    def _get_launcher_controller(self):
+        controllers = LauncherController.get_all_instances()
+        self.assertThat(len(controllers), Equals(1))
+        return controllers[0]
+
+    def _get_panel_controller(self):
+        controllers = PanelController.get_all_instances()
+        self.assertThat(len(controllers), Equals(1))
+        return controllers[0]
+
+    def _get_window_manager(self):
+        managers = WindowManager.get_all_instances()
+        self.assertThat(len(managers), Equals(1))
+        return managers[0]
+
+    def assertVisibleWindowStack(self, stack_start):
+        """Check that the visible window stack starts with the windows passed in.
+
+        The start_stack is an iterable of BamfWindow objects.
+        Minimised windows are skipped.
+
+        """
+        stack = [win for win in self.bamf.get_open_windows() if not win.is_hidden]
+        for pos, win in enumerate(stack_start):
+            self.assertThat(stack[pos].x_id, Equals(win.x_id),
+                            "%r at %d does not equal %r" % (stack[pos], pos, win))
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/autopilot/unity/tests/test_launcher.py'
--- tests/autopilot/unity/tests/test_launcher.py	2012-05-17 22:49:33 +0000
+++ tests/autopilot/unity/tests/test_launcher.py	2012-05-23 10:30:27 +0000
@@ -660,6 +660,7 @@
             logger.info("Checking for duplicated launcher icon for application %s", test_app.name)
             self.assertOnlyOneLauncherIcon(desktop_id=test_app.desktop_file)
 
+<<<<<<< TREE
     def test_killing_bamfdaemon_does_not_duplicate_application_xids(self):
         """Killing bamfdaemon should not duplicate any xid in the model."""
         self.start_test_apps()
@@ -685,6 +686,33 @@
 
 
 class LauncherCaptureTests(UnityTestCase):
+=======
+    def test_killing_bamfdaemon_does_not_duplicate_application_xids(self):
+        """Killing bamfdaemon should not duplicate any xid in the model."""
+        self.start_test_apps()
+        self.start_desktopless_test_apps()
+        self.kill_and_restart_bamfdaemon()
+
+        test_apps = self.get_test_apps() + self.get_desktopless_test_apps()
+
+        for test_app in test_apps:
+            logger.info("Checking for duplicated launcher icon for application %s", test_app.name)
+            test_windows = [w.x_id for w in test_app.get_windows()]
+            self.assertOnlyOneLauncherIcon(xids=test_windows)
+
+    def test_killing_bamfdaemon_does_not_duplicate_any_icon_application_id(self):
+        """Killing bamfdaemon should not duplicate any application ids in the model."""
+        self.start_test_apps()
+        self.start_desktopless_test_apps()
+        self.kill_and_restart_bamfdaemon()
+
+        for icon in self.launcher.model.get_bamf_launcher_icons():
+            logger.info("Checking for duplicated launcher icon %s", icon.tooltip_text)
+            self.assertOnlyOneLauncherIcon(application_id=icon.application_id)
+
+
+class LauncherCaptureTests(AutopilotTestCase):
+>>>>>>> MERGE-SOURCE
     """Test the launchers ability to capture/not capture the mouse."""
 
     screen_geo = ScreenGeometry()