Merge lp:~3v1n0/unity/unset-bamficon-on-removal-5.0 into lp:unity

[Marco Trevisan (Treviño)]

BamfLauncherIcon: Unset the BamfApplication when removing the icon.

Doing this manually, we prevent that a duplicated application can be added between the removal of the BamfLauncherIcon and the effective destruction (that is controlled by a timeout in LauncherModel).

Backporting fix for bug #1003574 to 5.0 branch https://code.launchpad.net/~3v1n0/unity/unset-bamficon-on-removal/+merge/107071

=== modified file 'CMakeLists.txt'
=== modified file 'dash/DashController.cpp'
--- dash/DashController.cpp	2012-05-22 15:46:04 +0000
+++ dash/DashController.cpp	2012-05-24 17:16:22 +0000
@@ -266,6 +266,10 @@
     need_show_ = true;
     return;
   }
+<<<<<<< TREE
+=======
+
+>>>>>>> MERGE-SOURCE
   view_->AboutToShow();
 
   window_->ShowWindow(true);

=== modified file 'dash/DashView.cpp'
=== modified file 'dash/LensBar.cpp'
=== modified file 'dash/LensBarIcon.cpp'
=== modified file 'dash/PlacesGroup.cpp'
=== modified file 'dash/ResultRendererTile.cpp'
=== modified file 'dash/ResultView.cpp'
=== modified file 'dash/ResultViewGrid.cpp'
=== modified file 'dash/ResultViewGrid.h'
=== modified file 'hud/HudController.cpp'
=== modified file 'hud/HudController.h'
=== modified file 'hud/HudIcon.h'
=== modified file 'hud/HudView.cpp'
=== modified file 'hud/HudView.h'
=== modified file 'launcher/AbstractLauncherIcon.h'
=== modified file 'launcher/BFBLauncherIcon.cpp'
=== modified file 'launcher/BamfLauncherIcon.cpp'
=== modified file 'launcher/DesktopLauncherIcon.cpp'
=== modified file 'launcher/DeviceLauncherIcon.cpp'
=== modified file 'launcher/HudLauncherIcon.cpp'
=== modified file 'launcher/Launcher.cpp'
=== modified file 'launcher/Launcher.h'
=== modified file 'launcher/LauncherController.cpp'
=== modified file 'launcher/LauncherIcon.cpp'
=== modified file 'launcher/LauncherIcon.h'
=== modified file 'launcher/QuicklistMenuItem.cpp'
=== modified file 'launcher/QuicklistMenuItem.h'
=== modified file 'launcher/QuicklistMenuItemSeparator.cpp'
=== modified file 'launcher/QuicklistView.cpp'
=== modified file 'launcher/QuicklistView.h'
=== modified file 'launcher/StandaloneLauncher.cpp'
--- launcher/StandaloneLauncher.cpp	2012-05-07 19:52:54 +0000
+++ launcher/StandaloneLauncher.cpp	2012-05-24 17:16:22 +0000
@@ -31,12 +31,22 @@
 #include "NuxGraphics/GraphicsEngine.h"
 #include <gtk/gtk.h>
 
+<<<<<<< TREE
 #include "unity-shared/BackgroundEffectHelper.h"
 #include "FavoriteStoreGSettings.h"
+=======
+#include "BackgroundEffectHelper.h"
+#include "FavoriteStoreGSettings.h"
+>>>>>>> MERGE-SOURCE
 #include "LauncherController.h"
 #include "Launcher.h"
+<<<<<<< TREE
 #include "unity-shared/PanelStyle.h"
 
+=======
+#include "PanelStyle.h"
+
+>>>>>>> MERGE-SOURCE
 #include <dbus/dbus-glib.h>
 
 using namespace unity;

=== modified file 'launcher/SwitcherController.cpp'
=== modified file 'launcher/SwitcherView.h'
--- launcher/SwitcherView.h	2012-05-17 11:52:32 +0000
+++ launcher/SwitcherView.h	2012-05-24 17:16:22 +0000
@@ -24,9 +24,15 @@
 #include "unity-shared/AbstractIconRenderer.h"
 #include "unity-shared/StaticCairoText.h"
 #include "LayoutSystem.h"
+<<<<<<< TREE
 #include "unity-shared/BackgroundEffectHelper.h"
 #include "unity-shared/UnityWindowView.h"
 
+=======
+#include "BackgroundEffectHelper.h"
+#include "UnityWindowView.h"
+
+>>>>>>> MERGE-SOURCE
 #include <boost/shared_ptr.hpp>
 #include <sigc++/sigc++.h>
 

=== modified file 'panel/PanelMenuView.cpp'
=== modified file 'panel/PanelView.cpp'
=== modified file 'panel/WindowButtons.cpp'
=== modified file 'plugins/unityshell/src/ScreenEffectFramebufferObject.cpp'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-05-24 07:23:12 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-05-24 17:16:22 +0000
@@ -101,6 +101,7 @@
 
 void unity::ScreenEffectFramebufferObject::bind (const nux::Geometry &output)
 {
+<<<<<<< TREE
   /* Very important!
    * Don't bind unless BackgroundEffectHelper says it's necessary.
    * Because binding has a severe impact on graphics performance and we
@@ -109,6 +110,11 @@
   if (!BackgroundEffectHelper::HasDirtyHelpers())
     return;
 
+=======
+  if (!BackgroundEffectHelper::HasDirtyHelpers())
+    return;
+
+>>>>>>> MERGE-SOURCE
   /* Clear the error bit */
   glGetError ();
 

=== modified file 'plugins/unityshell/src/unitya11y.cpp'
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-04-24 21:26:55 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-05-24 17:16:22 +0000
@@ -1449,8 +1449,11 @@
       ShowdesktopHandler::InhibitLeaveShowdesktopMode (event->xmaprequest.window);
       break;
     case PropertyNotify:
-      if (event->xproperty.window == GDK_ROOT_WINDOW())
+      if (event->xproperty.window == GDK_ROOT_WINDOW() &&
+          event->xproperty.atom == gdk_x11_get_xatom_by_name("_GNOME_BACKGROUND_REPRESENTATIVE_COLORS"))
+      {
         _bghash.RefreshColor();
+      }
       break;
     default:
         if (screen->shapeEvent () + ShapeNotify == event->type)

=== modified file 'plugins/unityshell/src/unityshell.h'
=== modified file 'shortcuts/ShortcutController.cpp'
=== modified file 'shortcuts/ShortcutView.cpp'
=== modified file 'shortcuts/ShortcutView.h'
=== added directory 'standalone-clients'
=== added file 'standalone-clients/CMakeLists.txt.OTHER'
--- standalone-clients/CMakeLists.txt.OTHER	1970-01-01 00:00:00 +0000
+++ standalone-clients/CMakeLists.txt.OTHER	2012-05-24 17:16:22 +0000
@@ -0,0 +1,574 @@
+set(UNITY_SRC ../plugins/unityshell/src)
+
+#
+# Data
+#
+
+#
+# Unit tests
+#
+find_package (PkgConfig)
+set (TEST_DEPS "${UNITY_PLUGIN_DEPS};unity>=4.0.0 xtst")
+pkg_check_modules (TEST_UNIT_DEPS REQUIRED ${TEST_DEPS})
+
+set (TESTDATADIR "${CMAKE_CURRENT_SOURCE_DIR}/data")
+
+set (CFLAGS
+     ${TEST_UNIT_DEPS_CFLAGS}
+     ${TEST_UNIT_DEPS_CFLAGS_OTHER}
+     ${MAINTAINER_CFLAGS}
+     "-g"
+     "-DTESTDATADIR=\"${TESTDATADIR}\""
+     "-DGETTEXT_PACKAGE=\"unity\""
+     "-DINDICATORDIR=\"${CMAKE_BINARY_DIR}/tests\""
+     "-DINDICATORICONDIR=\"${CMAKE_BINARY_DIR}/tests\""
+     "-I${CMAKE_CURRENT_BINARY_DIR}"
+     )
+add_definitions (${CFLAGS})
+
+set (LIBS ${TEST_UNIT_DEPS_LIBRARIES} "-lunity-core-${UNITY_API_VERSION} -lm -lGL -lGLU -lXtst")
+link_libraries (${LIBS})
+
+set (LIB_PATHS ${TEST_UNIT_DEPS_LIBRARY_DIRS})
+link_directories (${CMAKE_BINARY_DIR}/UnityCore ${LIB_PATHS})
+
+include_directories (. .. ../services ../UnityCore ${UNITY_SRC} ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
+
+# We can't have convenience libs so we need to rebuild with what we need
+# Please keep actual test files alphabetically at top and then files
+# from ../${UNITY_SRC} or ../../services in alphabetically after that
+
+#
+# Standalone tests
+#
+add_executable (dash
+                standalone_dash.cpp
+                ${UNITY_SRC}/AbstractPlacesGroup.cpp
+                ${UNITY_SRC}/AbstractPlacesGroup.h
+                ${UNITY_SRC}/AbstractSeparator.h
+                ${UNITY_SRC}/AbstractSeparator.cpp
+                ${UNITY_SRC}/BackgroundEffectHelper.cpp
+                ${UNITY_SRC}/BackgroundEffectHelper.h
+                ${UNITY_SRC}/BGHash.cpp
+                ${UNITY_SRC}/BGHash.h
+                ${UNITY_SRC}/SearchBar.cpp
+                ${UNITY_SRC}/SearchBar.h
+                ${UNITY_SRC}/SearchBarSpinner.cpp
+                ${UNITY_SRC}/SearchBarSpinner.h
+                ${UNITY_SRC}/DashView.cpp
+                ${UNITY_SRC}/DashView.h
+                ${UNITY_SRC}/DashViewPrivate.cpp
+                ${UNITY_SRC}/DashViewPrivate.h
+                ${UNITY_SRC}/DashSettings.cpp
+                ${UNITY_SRC}/DashSettings.h
+                ${UNITY_SRC}/FilterAllButton.cpp
+                ${UNITY_SRC}/FilterAllButton.h
+                ${UNITY_SRC}/FilterExpanderLabel.cpp
+                ${UNITY_SRC}/FilterFactory.cpp
+                ${UNITY_SRC}/FilterAllButton.cpp
+                ${UNITY_SRC}/FilterBasicButton.cpp
+                ${UNITY_SRC}/FilterRatingsButton.cpp
+                ${UNITY_SRC}/FilterRatingsWidget.cpp
+                ${UNITY_SRC}/FilterMultiRangeWidget.cpp
+                ${UNITY_SRC}/FilterMultiRangeButton.cpp
+                ${UNITY_SRC}/FilterGenreButton.cpp
+                ${UNITY_SRC}/FilterGenreWidget.cpp
+                ${UNITY_SRC}/FilterBar.cpp
+                ${UNITY_SRC}/FontSettings.cpp
+                ${UNITY_SRC}/FontSettings.h
+                ${UNITY_SRC}/IMTextEntry.cpp
+                ${UNITY_SRC}/IMTextEntry.h
+		${UNITY_SRC}/IntrospectableWrappers.cpp
+                ${UNITY_SRC}/PlacesGroup.cpp
+                ${UNITY_SRC}/PlacesGroup.h
+                ${UNITY_SRC}/PlacesTile.cpp
+                ${UNITY_SRC}/PlacesTile.h
+                ${UNITY_SRC}/PlacesSimpleTile.cpp
+                ${UNITY_SRC}/PlacesSimpleTile.h
+                ${UNITY_SRC}/PlacesVScrollBar.cpp
+                ${UNITY_SRC}/PlacesVScrollBar.h
+                ${UNITY_SRC}/DashView.cpp
+                ${UNITY_SRC}/DashView.h
+                ${UNITY_SRC}/DashViewPrivate.cpp
+                ${UNITY_SRC}/DashViewPrivate.h
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/IconLoader.cpp
+                ${UNITY_SRC}/IconLoader.h
+                ${UNITY_SRC}/IconTexture.cpp
+                ${UNITY_SRC}/IconTexture.h
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/Introspectable.h
+                ${UNITY_SRC}/JSONParser.cpp
+                ${UNITY_SRC}/LensBar.cpp
+                ${UNITY_SRC}/LensBar.h
+                ${UNITY_SRC}/LensBarIcon.cpp
+                ${UNITY_SRC}/LensBarIcon.h
+                ${UNITY_SRC}/LensView.cpp
+                ${UNITY_SRC}/LensView.h
+                ${UNITY_SRC}/LensViewPrivate.cpp
+                ${UNITY_SRC}/LensViewPrivate.h
+                ${UNITY_SRC}/LineSeparator.cpp
+                ${UNITY_SRC}/LineSeparator.h
+                ${UNITY_SRC}/OverlayRenderer.cpp
+                ${UNITY_SRC}/PreviewApplications.cpp
+                ${UNITY_SRC}/PreviewBase.cpp
+                ${UNITY_SRC}/PreviewBasicButton.cpp
+                ${UNITY_SRC}/ResultView.cpp
+                ${UNITY_SRC}/ResultViewGrid.cpp
+                ${UNITY_SRC}/ResultRenderer.cpp
+                ${UNITY_SRC}/ResultRendererTile.cpp
+                ${UNITY_SRC}/ResultRendererHorizontalTile.cpp
+                ${UNITY_SRC}/TextureCache.h
+                ${UNITY_SRC}/TextureCache.cpp
+                ${UNITY_SRC}/Timer.cpp
+                ${UNITY_SRC}/Timer.h
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/StaticCairoText.h
+                ${UNITY_SRC}/UBusMessages.h
+                ${UNITY_SRC}/UBusWrapper.cpp
+                ${UNITY_SRC}/UBusWrapper.h
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/ubus-server.h
+                ${UNITY_SRC}/UScreen.cpp
+                ${UNITY_SRC}/UScreen.h
+                )
+add_dependencies (dash unity-core-${UNITY_API_VERSION})
+
+add_executable (panel
+                TestPanel.cpp
+                ${UNITY_SRC}/Animator.cpp
+                ${UNITY_SRC}/Animator.h
+                ${UNITY_SRC}/BackgroundEffectHelper.cpp
+                ${UNITY_SRC}/BackgroundEffectHelper.h
+                ${UNITY_SRC}/DashSettings.cpp
+                ${UNITY_SRC}/DashSettings.h
+                ${UNITY_SRC}/PanelStyle.cpp
+                ${UNITY_SRC}/PanelStyle.h
+                ${UNITY_SRC}/PanelView.cpp
+                ${UNITY_SRC}/PanelView.h
+                ${UNITY_SRC}/PanelIndicatorsView.cpp
+                ${UNITY_SRC}/PanelIndicatorsView.h
+                ${UNITY_SRC}/PanelIndicatorEntryView.cpp
+                ${UNITY_SRC}/PanelIndicatorEntryView.h
+                ${UNITY_SRC}/PanelTitlebarGrabAreaView.h
+                ${UNITY_SRC}/PanelTitlebarGrabAreaView.cpp
+                ${UNITY_SRC}/PanelTray.cpp
+                ${UNITY_SRC}/PanelTray.h
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/Introspectable.h
+                ${UNITY_SRC}/PanelMenuView.cpp
+                ${UNITY_SRC}/PanelMenuView.h
+                ${UNITY_SRC}/Timer.cpp
+                ${UNITY_SRC}/Timer.h
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/StaticCairoText.h
+                ${UNITY_SRC}/WindowButtons.cpp
+                ${UNITY_SRC}/WindowButtons.h
+                ${UNITY_SRC}/WindowManager.cpp
+                ${UNITY_SRC}/WindowManager.h
+                ${UNITY_SRC}/UScreen.cpp
+                ${UNITY_SRC}/UScreen.h
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/ubus-server.h
+                )
+add_dependencies (panel unity-core-${UNITY_API_VERSION})
+
+add_executable (switcher
+                TestSwitcher.cpp
+                ${UNITY_SRC}/AbstractLauncherIcon.h
+                ${UNITY_SRC}/AbstractIconRenderer.h
+                ${UNITY_SRC}/SwitcherController.cpp
+                ${UNITY_SRC}/SwitcherController.h
+                ${UNITY_SRC}/SwitcherModel.cpp
+                ${UNITY_SRC}/SwitcherModel.h
+                ${UNITY_SRC}/SwitcherView.cpp
+                ${UNITY_SRC}/SwitcherView.h
+                ${UNITY_SRC}/LayoutSystem.h
+                ${UNITY_SRC}/LayoutSystem.cpp
+                ${UNITY_SRC}/WindowManager.h
+                ${UNITY_SRC}/WindowManager.cpp
+                ${UNITY_SRC}/IconRenderer.cpp
+                ${UNITY_SRC}/IconRenderer.h
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/Introspectable.h
+                ${UNITY_SRC}/MockLauncherIcon.h
+                ${UNITY_SRC}/BackgroundEffectHelper.h
+                ${UNITY_SRC}/BackgroundEffectHelper.cpp
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/StaticCairoText.h
+                ${UNITY_SRC}/UBusMessages.h
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/ubus-server.h
+                )
+add_dependencies (switcher unity-core-${UNITY_API_VERSION})
+
+add_executable (launcher
+                TestLauncher.cpp
+                ${UNITY_SRC}/CairoBaseWindow.cpp
+                ${UNITY_SRC}/AbstractLauncherIcon.h
+                ${UNITY_SRC}/AbstractLauncherIcon.cpp
+                ${UNITY_SRC}/AbstractIconRenderer.h
+                ${UNITY_SRC}/LauncherIcon.cpp
+                ${UNITY_SRC}/LauncherIcon.h
+                ${UNITY_SRC}/SimpleLauncherIcon.cpp
+                ${UNITY_SRC}/SimpleLauncherIcon.h
+                ${UNITY_SRC}/BamfLauncherIcon.cpp
+                ${UNITY_SRC}/BamfLauncherIcon.h
+                ${UNITY_SRC}/BFBLauncherIcon.cpp
+                ${UNITY_SRC}/BFBLauncherIcon.h
+                ${UNITY_SRC}/SpacerLauncherIcon.cpp
+                ${UNITY_SRC}/SpacerLauncherIcon.h
+                ${UNITY_SRC}/DndData.cpp
+                ${UNITY_SRC}/DndData.h
+                ${UNITY_SRC}/TrashLauncherIcon.cpp
+                ${UNITY_SRC}/TrashLauncherIcon.h
+                ${UNITY_SRC}/Decaymulator.cpp
+                ${UNITY_SRC}/Decaymulator.h
+                ${UNITY_SRC}/DesktopLauncherIcon.cpp
+                ${UNITY_SRC}/DesktopLauncherIcon.h
+                ${UNITY_SRC}/DNDCollectionWindow.cpp
+                ${UNITY_SRC}/DNDCollectionWindow.h
+                ${UNITY_SRC}/DeviceLauncherIcon.cpp
+                ${UNITY_SRC}/DeviceLauncherIcon.h
+                ${UNITY_SRC}/DeviceLauncherSection.cpp
+                ${UNITY_SRC}/DeviceLauncherSection.h
+                ${UNITY_SRC}/DevicesSettings.cpp
+                ${UNITY_SRC}/DevicesSettings.h
+                ${UNITY_SRC}/EdgeBarrierController.h
+                ${UNITY_SRC}/EdgeBarrierController.cpp
+                ${UNITY_SRC}/FavoriteStore.cpp
+                ${UNITY_SRC}/FavoriteStore.h
+                ${UNITY_SRC}/FavoriteStoreGSettings.cpp
+                ${UNITY_SRC}/FavoriteStoreGSettings.h
+                ${UNITY_SRC}/FavoriteStorePrivate.cpp
+                ${UNITY_SRC}/FavoriteStorePrivate.h
+                ${UNITY_SRC}/HudLauncherIcon.cpp
+                ${UNITY_SRC}/HudLauncherIcon.h
+                ${UNITY_SRC}/IconLoader.cpp
+                ${UNITY_SRC}/IconLoader.h
+                ${UNITY_SRC}/IconTextureSource.h
+                ${UNITY_SRC}/IconTextureSource.cpp
+                ${UNITY_SRC}/LauncherOptions.cpp
+                ${UNITY_SRC}/LauncherOptions.h
+                ${UNITY_SRC}/LauncherEntryRemoteModel.cpp
+                ${UNITY_SRC}/LauncherEntryRemoteModel.h
+                ${UNITY_SRC}/LauncherEntryRemote.cpp
+                ${UNITY_SRC}/LauncherEntryRemote.h
+                ${UNITY_SRC}/LauncherController.cpp
+                ${UNITY_SRC}/LauncherController.h
+                ${UNITY_SRC}/LauncherModel.cpp
+                ${UNITY_SRC}/LauncherModel.h
+                ${UNITY_SRC}/Launcher.cpp
+                ${UNITY_SRC}/Launcher.h
+                ${UNITY_SRC}/LauncherHideMachine.cpp
+                ${UNITY_SRC}/LauncherHideMachine.h
+                ${UNITY_SRC}/LauncherHoverMachine.cpp
+                ${UNITY_SRC}/LauncherHoverMachine.h
+                ${UNITY_SRC}/LauncherDragWindow.cpp
+                ${UNITY_SRC}/LauncherDragWindow.h
+                ${UNITY_SRC}/GeisAdapter.cpp
+                ${UNITY_SRC}/GeisAdapter.h
+                ${UNITY_SRC}/WindowManager.h
+                ${UNITY_SRC}/WindowManager.cpp
+                ${UNITY_SRC}/IconRenderer.cpp
+                ${UNITY_SRC}/IconRenderer.h
+                ${UNITY_SRC}/Tooltip.cpp
+                ${UNITY_SRC}/Tooltip.h
+                ${UNITY_SRC}/BackgroundEffectHelper.h
+                ${UNITY_SRC}/BackgroundEffectHelper.cpp
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/StaticCairoText.h
+                ${UNITY_SRC}/SingleMonitorLauncherIcon.cpp
+                ${UNITY_SRC}/SingleMonitorLauncherIcon.h
+                ${UNITY_SRC}/SoftwareCenterLauncherIcon.cpp
+                ${UNITY_SRC}/SoftwareCenterLauncherIcon.h
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/Introspectable.h
+                ${UNITY_SRC}/PanelStyle.cpp
+                ${UNITY_SRC}/PanelStyle.h
+                ${UNITY_SRC}/PointerBarrier.cpp
+                ${UNITY_SRC}/PointerBarrier.h
+                ${UNITY_SRC}/QuicklistMenuItem.cpp
+                ${UNITY_SRC}/QuicklistMenuItem.h
+                ${UNITY_SRC}/QuicklistMenuItemCheckmark.cpp
+                ${UNITY_SRC}/QuicklistMenuItemCheckmark.h
+                ${UNITY_SRC}/QuicklistMenuItemLabel.cpp
+                ${UNITY_SRC}/QuicklistMenuItemLabel.h
+                ${UNITY_SRC}/QuicklistMenuItemRadio.cpp
+                ${UNITY_SRC}/QuicklistMenuItemRadio.h
+                ${UNITY_SRC}/QuicklistMenuItemSeparator.cpp
+                ${UNITY_SRC}/QuicklistMenuItemSeparator.h
+                ${UNITY_SRC}/QuicklistView.cpp
+                ${UNITY_SRC}/QuicklistView.h
+                ${UNITY_SRC}/QuicklistManager.cpp
+                ${UNITY_SRC}/QuicklistManager.h
+                ${UNITY_SRC}/TextureCache.cpp
+                ${UNITY_SRC}/TextureCache.h
+                ${UNITY_SRC}/Timer.cpp
+                ${UNITY_SRC}/Timer.h
+                ${UNITY_SRC}/UBusMessages.h
+                ${UNITY_SRC}/UBusWrapper.cpp
+                ${UNITY_SRC}/UBusWrapper.h
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/ubus-server.h
+                ${UNITY_SRC}/UScreen.cpp
+                ${UNITY_SRC}/UScreen.h
+                )
+add_dependencies (launcher unity-core-${UNITY_API_VERSION})
+
+add_executable (keyutil
+                TestKeyboardUtil.cpp
+                ${UNITY_SRC}/KeyboardUtil.h
+                ${UNITY_SRC}/KeyboardUtil.cpp
+                )
+add_dependencies (keyutil unity-core-${UNITY_API_VERSION})
+
+add_executable (quicklist
+                ui/TestQuicklist.cpp
+                nux_test_framework.cpp
+                nux_test_framework.h
+                nux_automated_test_framework.cpp
+                nux_automated_test_framework.h
+                ${UNITY_SRC}/CairoBaseWindow.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/QuicklistMenuItem.cpp
+                ${UNITY_SRC}/QuicklistMenuItemCheckmark.cpp
+                ${UNITY_SRC}/QuicklistMenuItemLabel.cpp
+                ${UNITY_SRC}/QuicklistMenuItemRadio.cpp
+                ${UNITY_SRC}/QuicklistMenuItemSeparator.cpp
+                ${UNITY_SRC}/QuicklistView.cpp
+                ${UNITY_SRC}/ubus-server.cpp
+                )
+add_dependencies(quicklist unity-core-${UNITY_API_VERSION})
+
+add_executable (quicklist-visuals
+                ui/TestQuicklistVisuals.cpp
+                ui/EventFaker.cpp
+                ui/EventFaker.h
+                ${UNITY_SRC}/CairoBaseWindow.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/QuicklistMenuItem.cpp
+                ${UNITY_SRC}/QuicklistMenuItemCheckmark.cpp
+                ${UNITY_SRC}/QuicklistMenuItemLabel.cpp
+                ${UNITY_SRC}/QuicklistMenuItemRadio.cpp
+                ${UNITY_SRC}/QuicklistMenuItemSeparator.cpp
+                ${UNITY_SRC}/QuicklistView.cpp
+                ${UNITY_SRC}/ubus-server.cpp
+                )
+add_dependencies(quicklist-visuals unity-core-${UNITY_API_VERSION})
+
+add_executable (filters
+                TestFilters.cpp
+                ${UNITY_SRC}/FilterExpanderLabel.cpp
+                ${UNITY_SRC}/FilterBasicButton.cpp
+                ${UNITY_SRC}/FilterRatingsButton.cpp
+                ${UNITY_SRC}/FilterRatingsWidget.cpp
+                ${UNITY_SRC}/FilterGenreButton.cpp
+                ${UNITY_SRC}/FilterGenreWidget.cpp
+                ${UNITY_SRC}/FilterMultiRangeButton.cpp
+                ${UNITY_SRC}/FilterMultiRangeWidget.cpp
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/JSONParser.cpp
+                )
+add_dependencies(filters unity-core-${UNITY_API_VERSION})
+
+add_executable (filter-bar
+                TestFilterBar.cpp
+                ${UNITY_SRC}/FilterAllButton.cpp
+                ${UNITY_SRC}/FilterBar.cpp
+                ${UNITY_SRC}/FilterBasicButton.cpp
+                ${UNITY_SRC}/FilterExpanderLabel.cpp
+                ${UNITY_SRC}/FilterFactory.cpp
+                ${UNITY_SRC}/FilterMultiRangeWidget.cpp
+                ${UNITY_SRC}/FilterMultiRangeButton.cpp
+                ${UNITY_SRC}/FilterGenreButton.cpp
+                ${UNITY_SRC}/FilterGenreWidget.cpp
+                ${UNITY_SRC}/FilterRatingsButton.cpp
+                ${UNITY_SRC}/FilterRatingsWidget.cpp
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/JSONParser.cpp
+                )
+add_dependencies(filter-bar unity-core-${UNITY_API_VERSION})
+
+add_executable (preview-applicaiton
+                TestPreviewApplications.cpp
+                ${UNITY_SRC}/PreviewApplications.cpp
+                ${UNITY_SRC}/PreviewBase.cpp
+                ${UNITY_SRC}/PreviewBasicButton.cpp
+                ${UNITY_SRC}/IconTexture.cpp
+                ${UNITY_SRC}/IconLoader.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/TextureCache.cpp
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/JSONParser.cpp
+                ${UNITY_SRC}/Timer.cpp
+                )
+add_dependencies(preview-applicaiton unity-core-${UNITY_API_VERSION})
+
+add_executable (preview-generic
+                TestPreviewGeneric.cpp
+                ${UNITY_SRC}/PreviewGeneric.cpp
+                ${UNITY_SRC}/PreviewBase.cpp
+                ${UNITY_SRC}/PreviewBasicButton.cpp
+                ${UNITY_SRC}/IconTexture.cpp
+                ${UNITY_SRC}/IconLoader.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/TextureCache.cpp
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/JSONParser.cpp
+                ${UNITY_SRC}/Timer.cpp
+                )
+add_dependencies(preview-generic unity-core-${UNITY_API_VERSION})
+
+add_executable (preview-music
+                TestPreviewMusic.cpp
+                ${UNITY_SRC}/PreviewBase.cpp
+                ${UNITY_SRC}/PreviewBasicButton.cpp
+                ${UNITY_SRC}/PreviewMusic.cpp
+                ${UNITY_SRC}/PreviewMusicTrack.cpp
+                ${UNITY_SRC}/PreviewMusicTrackWidget.cpp
+                ${UNITY_SRC}/IconTexture.cpp
+                ${UNITY_SRC}/IconLoader.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/TextureCache.cpp
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/JSONParser.cpp
+                ${UNITY_SRC}/Timer.cpp
+                )
+add_dependencies(preview-music unity-core-${UNITY_API_VERSION})
+
+add_executable (result-view
+                TestResultView.cpp
+                ${UNITY_SRC}/PreviewApplications.cpp
+                ${UNITY_SRC}/PreviewBase.cpp
+                ${UNITY_SRC}/PreviewBasicButton.cpp
+                ${UNITY_SRC}/ResultView.cpp
+                ${UNITY_SRC}/ResultViewGrid.cpp
+                ${UNITY_SRC}/ResultRenderer.cpp
+                ${UNITY_SRC}/ResultRendererTile.cpp
+                ${UNITY_SRC}/ResultRendererHorizontalTile.cpp
+                ${UNITY_SRC}/IconTexture.cpp
+                ${UNITY_SRC}/IconLoader.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/TextureCache.cpp
+                ${UNITY_SRC}/Timer.cpp
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/JSONParser.cpp
+                ${UNITY_SRC}/UBusMessages.h
+                ${UNITY_SRC}/UBusWrapper.cpp
+                ${UNITY_SRC}/UBusWrapper.h
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/ubus-server.h
+                )
+add_dependencies(result-view unity-core-${UNITY_API_VERSION})
+
+add_executable (dash-style
+                TestDashStyle.cpp
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/DashStyle.h
+                ${UNITY_SRC}/JSONParser.cpp
+                ${PLACES_COMMON_SOURCE}
+                )
+add_dependencies(dash-style unity-core-${UNITY_API_VERSION})
+
+add_executable (bg-hash
+                TestBGHash.cpp
+                ${UNITY_SRC}/BGHash.cpp
+                ${UNITY_SRC}/BGHash.h
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/ubus-server.h
+               )
+add_dependencies (bg-hash unity-core-${UNITY_API_VERSION})
+
+add_executable (hud
+                StandaloneHud.cpp
+                ${UNITY_SRC}/BackgroundEffectHelper.cpp
+                ${UNITY_SRC}/BackgroundEffectHelper.h
+                ${UNITY_SRC}/DashSettings.cpp
+                ${UNITY_SRC}/DashSettings.h
+                ${UNITY_SRC}/DashStyle.cpp
+                ${UNITY_SRC}/HudButton.cpp
+                ${UNITY_SRC}/HudIcon.cpp
+                ${UNITY_SRC}/HudIcon.h
+                ${UNITY_SRC}/HudIconTextureSource.cpp
+                ${UNITY_SRC}/HudIconTextureSource.h
+                ${UNITY_SRC}/HudView.cpp
+                ${UNITY_SRC}/IMTextEntry.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/IconTexture.cpp
+                ${UNITY_SRC}/IconLoader.cpp
+                ${UNITY_SRC}/IconRenderer.cpp
+                ${UNITY_SRC}/IconTextureSource.cpp
+                ${UNITY_SRC}/JSONParser.cpp
+                ${UNITY_SRC}/OverlayRenderer.cpp
+                ${UNITY_SRC}/SearchBar.cpp
+                ${UNITY_SRC}/SearchBarSpinner.cpp
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/TextureCache.cpp
+                ${UNITY_SRC}/Timer.cpp
+                ${UNITY_SRC}/UBusWrapper.cpp
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/UScreen.cpp
+                ${UNITY_SRC}/UScreen.h
+               )
+add_dependencies (hud unity-core-${UNITY_API_VERSION})
+
+add_executable (test-shortcut
+                TestShortcut.cpp
+                ${UNITY_SRC}/AbstractSeparator.cpp
+                ${UNITY_SRC}/AbstractSeparator.h
+                ${UNITY_SRC}/AbstractShortcutHint.h
+                ${UNITY_SRC}/Animator.cpp
+                ${UNITY_SRC}/Animator.h
+                ${UNITY_SRC}/BackgroundEffectHelper.cpp
+                ${UNITY_SRC}/BackgroundEffectHelper.h
+                ${UNITY_SRC}/LineSeparator.cpp
+                ${UNITY_SRC}/LineSeparator.h
+                ${UNITY_SRC}/MockShortcutHint.h
+                ${UNITY_SRC}/ShortcutController.cpp
+                ${UNITY_SRC}/ShortcutController.h
+                ${UNITY_SRC}/ShortcutModel.cpp
+                ${UNITY_SRC}/ShortcutModel.h
+                ${UNITY_SRC}/ShortcutView.cpp
+                ${UNITY_SRC}/ShortcutView.h
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/StaticCairoText.h
+                ${UNITY_SRC}/UBusMessages.h
+                ${UNITY_SRC}/ubus-server.cpp
+                ${UNITY_SRC}/ubus-server.h
+                )
+
+add_executable (tooltip
+                ui/TestTooltip.cpp
+                ${UNITY_SRC}/Introspectable.cpp
+                ${UNITY_SRC}/CairoBaseWindow.cpp
+                ${UNITY_SRC}/StaticCairoText.cpp
+                ${UNITY_SRC}/Tooltip.cpp
+                ${UNITY_SRC}/ubus-server.cpp
+                )
+add_dependencies(quicklist unity-core-${UNITY_API_VERSION})
+
+find_package (OpenGL)
+include_directories (${OPENGL_gl_INCDIRS})
+add_library (glfuncloader SHARED
+	     ${CMAKE_CURRENT_SOURCE_DIR}/GLFuncLoader.cpp)
+add_dependencies (glfuncloader unity-core-${UNITY_API_VERSION})
+target_link_libraries (glfuncloader dl ${OPENGL_gl_LIBRARY})
+add_executable (screen-effect-fbo
+		TestScreenEffectFramebufferObject.cpp
+		${UNITY_SRC}/ScreenEffectFramebufferObject.cpp
+		${UNITY_SRC}/BackgroundEffectHelper.cpp)
+
+target_link_libraries (screen-effect-fbo glfuncloader ${OPENGL_gl_LIBRARY})
+add_dependencies (screen-effect-fbo ${UNITY_API_VERSION})
+
+# Custom target to make all the other targets here, add your test to this list
+add_custom_target(standalone-clients DEPENDS dash panel launcher switcher keyutil quicklist quicklist-visuals filters filter-bar preview-applicaiton preview-generic preview-music result-view dash-style bg-hash shortcut-view tooltip)
+
+
+
+

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-05-22 15:48:31 +0000
+++ tests/CMakeLists.txt	2012-05-24 17:16:22 +0000
@@ -205,6 +205,7 @@
                  test_single_monitor_launcher_icon.cpp
                  test_switcher_controller.cpp
                  test_switcher_model.cpp
+<<<<<<< TREE
                  ${CMAKE_SOURCE_DIR}/dash/AbstractPlacesGroup.cpp
                  ${CMAKE_SOURCE_DIR}/dash/DashViewPrivate.cpp
                  ${CMAKE_SOURCE_DIR}/dash/LensViewPrivate.cpp
@@ -257,6 +258,59 @@
                  ${CMAKE_SOURCE_DIR}/unity-shared/UnityWindowView.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/WindowManager.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/ubus-server.cpp
+=======
+                 ${UNITY_SRC}/AbstractLauncherIcon.cpp
+                 ${UNITY_SRC}/AbstractPlacesGroup.cpp
+                 ${UNITY_SRC}/BackgroundEffectHelper.cpp
+                 ${UNITY_SRC}/CairoBaseWindow.cpp
+                 ${UNITY_SRC}/DashViewPrivate.cpp
+                 ${UNITY_SRC}/Decaymulator.cpp
+                 ${UNITY_SRC}/DNDCollectionWindow.cpp
+                 ${UNITY_SRC}/DndData.cpp
+                 ${UNITY_SRC}/GeisAdapter.cpp
+                 ${UNITY_SRC}/IconLoader.cpp
+                 ${UNITY_SRC}/IconRenderer.cpp
+                 ${UNITY_SRC}/IconTextureSource.cpp
+                 ${UNITY_SRC}/Introspectable.cpp
+                 ${UNITY_SRC}/LayoutSystem.cpp
+                 ${UNITY_SRC}/Launcher.cpp
+                 ${UNITY_SRC}/LauncherDragWindow.cpp
+                 ${UNITY_SRC}/LauncherEntryRemote.cpp
+                 ${UNITY_SRC}/LauncherHideMachine.cpp
+                 ${UNITY_SRC}/LauncherHoverMachine.cpp
+                 ${UNITY_SRC}/LauncherIcon.cpp
+                 ${UNITY_SRC}/LauncherModel.cpp
+                 ${UNITY_SRC}/SimpleLauncherIcon.cpp
+                 ${UNITY_SRC}/SingleMonitorLauncherIcon.cpp
+                 ${UNITY_SRC}/LensViewPrivate.cpp
+                 ${UNITY_SRC}/StaticCairoText.cpp
+                 ${UNITY_SRC}/SwitcherController.cpp
+                 ${UNITY_SRC}/SwitcherModel.cpp
+                 ${UNITY_SRC}/SwitcherView.cpp
+                 ${UNITY_SRC}/Timer.cpp
+                 ${UNITY_SRC}/Tooltip.cpp
+                 ${UNITY_SRC}/PanelStyle.cpp
+                 ${UNITY_SRC}/PointerBarrier.cpp
+                 ${UNITY_SRC}/QuicklistView.cpp
+                 ${UNITY_SRC}/QuicklistManager.cpp
+                 ${UNITY_SRC}/QuicklistMenuItem.cpp
+                 ${UNITY_SRC}/QuicklistMenuItemCheckmark.cpp
+                 ${UNITY_SRC}/QuicklistMenuItemLabel.cpp
+                 ${UNITY_SRC}/QuicklistMenuItemRadio.cpp
+                 ${UNITY_SRC}/QuicklistMenuItemSeparator.cpp
+                 ${UNITY_SRC}/SpacerLauncherIcon.cpp
+                 ${UNITY_SRC}/TextureCache.cpp
+                 ${UNITY_SRC}/UBusWrapper.cpp
+                 ${UNITY_SRC}/UnityWindowStyle.cpp
+                 ${UNITY_SRC}/UnityWindowView.cpp
+                 ${UNITY_SRC}/ubus-server.cpp
+                 ${UNITY_SRC}/UScreen.cpp
+                 ${UNITY_SRC}/WindowManager.cpp
+                 ${UNITY_SRC}/ResultView.cpp
+                 ${UNITY_SRC}/ResultViewGrid.cpp
+                 ${UNITY_SRC}/ResultRenderer.cpp
+                 ${UNITY_SRC}/IntrospectableWrappers.cpp
+>>>>>>> MERGE-SOURCE
                 )
   target_link_libraries(test-gtest gtest gmock ${LIBS})
   add_test(UnityGTest test-gtest)

=== 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-24 17:16:22 +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'))

=== added file 'tests/autopilot/autopilot/keybindings.py.OTHER'
--- tests/autopilot/autopilot/keybindings.py.OTHER	1970-01-01 00:00:00 +0000
+++ tests/autopilot/autopilot/keybindings.py.OTHER	2012-05-24 17:16:22 +0000
@@ -0,0 +1,259 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2012 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.
+
+"""Utility functions to get shortcut keybindings for various parts of Unity.
+
+Inside autopilot we deal with keybindings by naming them with unique names. For
+example, instead of hard-coding the fact that 'Alt+F2' opens the command lens, we
+might call:
+
+>>> keybindings.get('lens_reveal/command')
+'Alt+F2'
+
+Keybindings come from two different places:
+ 1) Keybindings from compiz. We can get these if we have the plugin name and
+    setting name.
+ 2) Elsewhere. Right now we're hard-coding these in a separate dictionary.
+"""
+
+from compizconfig import Plugin, Setting
+import logging
+from types import NoneType
+import re
+
+from autopilot.emulators.X11 import Keyboard
+from autopilot.globals import global_context
+
+
+logger = logging.getLogger(__name__)
+
+
+#
+# Fill this dictionary with keybindings we want to store.
+#
+# If keybindings are from compizconfig, the value should be a 2-value tuple
+# containging (plugin_name, setting_name).
+#
+# If keybindings are elsewhere, just store the keybinding string.
+_keys = {
+    # Launcher:
+    "launcher/reveal": ('unityshell', 'show_launcher'),
+    "launcher/keynav": ('unityshell', 'keyboard_focus'),
+    "launcher/keynav/next": "Down",
+    "launcher/keynav/prev": "Up",
+    "launcher/keynav/activate": "Enter",
+    "launcher/keynav/exit": "Escape",
+    "launcher/keynav/open-quicklist": "Right",
+    "launcher/keynav/close-quicklist": "Left",
+    "launcher/switcher": ('unityshell', 'launcher_switcher_forward'),
+    "launcher/switcher/exit": "Escape",
+    "launcher/switcher/next": "Tab",
+    "launcher/switcher/prev": "Shift+Tab",
+    "launcher/switcher/down": "Down",
+    "launcher/switcher/up": "Up",
+    # Quicklist:
+    "quicklist/keynav/first": "Home",
+    "quicklist/keynav/last": "End",
+    "quicklist/keynav/next": "Down",
+    "quicklist/keynav/prev": "Up",
+    "quicklist/keynav/activate": "Enter",
+    "quicklist/keynav/exit": "Escape",
+    # Panel:
+    "panel/show_menus": "Alt",
+    "panel/open_first_menu": ('unityshell', 'panel_first_menu'),
+    "panel/next_indicator": "Right",
+    "panel/prev_indicator": "Left",
+    # Dash:
+    "dash/reveal": "Super",
+    "dash/lens/next": "Ctrl+Tab",
+    "dash/lens/prev": "Ctrl+Shift+Tab",
+    # Lenses:
+    "lens_reveal/command": ("unityshell", "execute_command"),
+    "lens_reveal/apps": "Super+a",
+    "lens_reveal/files": "Super+f",
+    "lens_reveal/music": "Super+m",
+    # Hud:
+    "hud/reveal": ("unityshell", "show_hud"),
+    # Switcher:
+    "switcher/reveal_normal": ("unityshell", "alt_tab_forward"),
+    "switcher/reveal_impropper": "Alt+Right",
+    "switcher/reveal_details": "Alt+`",
+    "switcher/reveal_all": ("unityshell", "alt_tab_forward_all"),
+    "switcher/cancel": "Escape",
+    # Shortcut Hint:
+    "shortcuthint/reveal": ('unityshell', 'show_launcher'),
+    "shortcuthint/cancel": "Escape",
+    # These are in compiz as 'Alt+Right' and 'Alt+Left', but the fact that it
+    # lists the Alt key won't work for us, so I'm defining them manually.
+    "switcher/next": "Tab",
+    "switcher/prev": "Shift+Tab",
+    "switcher/right": "Right",
+    "switcher/left": "Left",
+    "switcher/detail_start": "Down",
+    "switcher/detail_stop": "Up",
+    "switcher/detail_next": "`",
+    "switcher/detail_prev": "`",
+    # Workspace switcher (wall):
+    "workspace/move_left": ("wall", "left_key"),
+    "workspace/move_right": ("wall", "right_key"),
+    "workspace/move_up": ("wall", "up_key"),
+    "workspace/move_down": ("wall", "down_key"),
+    # Window management:
+    "window/show_desktop" : ("core", "show_desktop_key"),
+    "window/minimize": ("core", "minimize_window_key"),
+    "window/maximize": ("core", "maximize_window_key"),
+    "window/restore": ("core", "unmaximize_window_key"),
+    "window/close": ("core", "close_window_key"),
+    # expo plugin:
+    "expo/start": ("expo", "expo_key"),
+    "expo/cancel": "Escape",
+    # spread (scale) plugin:
+    "spread/start": ("scale", "initiate_all_key"),
+    "spread/cancel": "Escape",
+}
+
+
+
+def get(binding_name):
+    """Get a keybinding, given its well-known name.
+
+    binding_name must be a string, or a TypeError will be raised.
+
+    If binding_name cannot be found in the bindings dictionaries, a ValueError
+    will be raised.
+
+    """
+    if not isinstance(binding_name, basestring):
+        raise TypeError("binding_name must be a string.")
+    if binding_name not in _keys:
+        raise ValueError("Unknown binding name '%s'." % (binding_name))
+    v = _keys[binding_name]
+    if isinstance(v, basestring):
+        return v
+    else:
+        return _get_compiz_keybinding(v)
+
+
+def get_hold_part(binding_name):
+    """Returns the part of a keybinding that must be held permenantly.
+
+    Use this function to split bindings like "Alt+Tab" into the part that must be
+    held down. See get_tap_part for the part that must be tapped.
+
+    Raises a ValueError if the binding specified does not have multiple parts.
+
+    """
+    binding = get(binding_name)
+    parts = binding.split('+')
+    if len(parts) == 1:
+        logger.warning("Key binding '%s' does not have a hold part.", binding_name)
+        return parts[0]
+    return '+'.join(parts[:-1])
+
+
+def get_tap_part(binding_name):
+    """Returns the part of a keybinding that must be tapped.
+
+    Use this function to split bindings like "Alt+Tab" into the part that must be
+    held tapped. See get_hold_part for the part that must be held down.
+
+    Raises a ValueError if the binding specified does not have multiple parts.
+
+    """
+    binding = get(binding_name)
+    parts = binding.split('+')
+    if len(parts) == 1:
+        logger.warning("Key binding '%s' does not have a tap part.", binding_name)
+        return parts[0]
+    return parts[-1]
+
+
+def _get_compiz_keybinding(compiz_tuple):
+    """Given a keybinding name, get the keybinding string from the compiz option.
+
+    Raises ValueError if the compiz setting described does not hold a keybinding.
+    Raises RuntimeError if the compiz keybinding has been disabled.
+
+    """
+    plugin_name, setting_name = compiz_tuple
+    plugin = Plugin(global_context, plugin_name)
+    setting = Setting(plugin, setting_name)
+    if setting.Type != 'Key':
+        raise ValueError("Key binding maps to a compiz option that does not hold a keybinding.")
+    if not plugin.Enabled:
+        logger.warning("Returning keybinding for '%s' which is in un-enabled plugin '%s'",
+            setting.ShortDesc,
+            plugin.ShortDesc)
+    if setting.Value == "Disabled":
+        raise RuntimeError("Keybinding '%s' in compiz plugin '%s' has been disabled." %
+            (setting.ShortDesc, plugin.ShortDesc))
+
+    return _translate_compiz_keystroke_string(setting.Value)
+
+
+def _translate_compiz_keystroke_string(keystroke_string):
+    """Get a string representing the keystroke stored in `keystroke_string`.
+
+    `keystroke_string` is a compizconfig-style keystroke string.
+
+    The returned value is suitable for passing into the Keyboard emulator.
+
+    """
+    if not isinstance(keystroke_string, basestring):
+        raise TypeError("keystroke string must be a string.")
+
+    translations = {
+        'Control': 'Ctrl',
+        'Primary': 'Ctrl',
+    }
+    regex = re.compile('[<>]')
+    parts = regex.split(keystroke_string)
+    result = []
+    for part in parts:
+        part = part.strip()
+        if part != "" and not part.isspace():
+            translated = translations.get(part, part)
+            if translated not in result:
+                result.append(translated)
+
+    return '+'.join(result)
+
+
+class KeybindingsHelper(object):
+    """A helper class that makes it easier to use unity keybindings."""
+    _keyboard = Keyboard()
+
+    def keybinding(self, binding_name, delay=None):
+        """Press and release the keybinding with the given name.
+
+        If set, the delay parameter will override the default delay set by the
+        keyboard emulator.
+
+        """
+        if type(delay) not in (float, NoneType):
+            raise TypeError("delay parameter must be a float if it is defined.")
+        if delay:
+            self._keyboard.press_and_release(get(binding_name), delay)
+        else:
+            self._keyboard.press_and_release(get(binding_name))
+
+    def keybinding_hold(self, binding_name):
+        """Hold down the hold-part of a keybinding."""
+        self._keyboard.press(get_hold_part(binding_name))
+
+    def keybinding_release(self, binding_name):
+        """Release the hold-part of a keybinding."""
+        self._keyboard.release(get_hold_part(binding_name))
+
+    def keybinding_tap(self, binding_name):
+        """Tap the tap-part of a keybinding."""
+        self._keyboard.press_and_release(get_tap_part(binding_name))
+
+    def keybinding_hold_part_then_tap(self, binding_name):
+        self.keybinding_hold(binding_name)
+        self.keybinding_tap(binding_name)

=== added directory 'tests/autopilot/autopilot/matchers'
=== added file 'tests/autopilot/autopilot/matchers/__init__.py'
--- tests/autopilot/autopilot/matchers/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/autopilot/matchers/__init__.py	2012-05-24 17:16:22 +0000
@@ -0,0 +1,31 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2012 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.
+
+"Autopilot-specific matchers."
+
+from testtools.matchers import Matcher
+
+
+class Eventually(Matcher):
+    """Asserts that a value will eventually equal a given Matcher object."""
+
+    def __init__(self, matcher):
+        super(Eventually, self).__init__()
+        match_fun = getattr(matcher, 'match', None)
+        if match_fun is None or not callable(match_fun):
+            raise TypeError("Eventually must be called with a testtools matcher argument.")
+        self.matcher = matcher
+
+    def match(self, value):
+        wait_fun = getattr(value, 'wait_for', None)
+        if wait_fun is None or not callable(wait_fun):
+            raise TypeError("Eventually can only be used against autopilot attributes that have a wait_for funtion.")
+        wait_fun(self.matcher)
+
+    def __str__(self):
+        return "Eventually " + str(self.matcher)

=== modified file 'tests/autopilot/unity/emulators/__init__.py'
--- tests/autopilot/unity/emulators/__init__.py	2012-05-08 16:13:17 +0000
+++ tests/autopilot/unity/emulators/__init__.py	2012-05-24 17:16:22 +0000
@@ -7,4 +7,293 @@
 # by the Free Software Foundation.
 #
 
+<<<<<<< TREE
 """A collection of Unity-specific emulators."""
+=======
+from dbus import Interface
+import logging
+from testtools.matchers import Equals
+from time import sleep
+
+from autopilot.emulators.dbus_handler import session_bus
+
+_object_registry = {}
+logger = logging.getLogger(__name__)
+
+
+class StateNotFoundError(RuntimeError):
+    """Raised when a piece of state information from unity is not found."""
+
+    message = "State not found for class with name '{}' and id '{}'."
+
+    def __init__(self, class_name, class_id):
+        super(StateNotFoundError, self).__init__(self.message.format(class_name, class_id))
+
+
+class IntrospectableObjectMetaclass(type):
+    """Metaclass to insert appropriate classes into the object registry."""
+
+    def __new__(cls, classname, bases, classdict):
+        """Add class name to type registry."""
+        class_object = type.__new__(cls, classname, bases, classdict)
+        _object_registry[classname] = class_object
+        return class_object
+
+
+# acquire the debugging dbus object
+UNITY_BUS_NAME = 'com.canonical.Unity'
+DEBUG_PATH = '/com/canonical/Unity/Debug'
+INTROSPECTION_IFACE = 'com.canonical.Unity.Debug.Introspection'
+
+
+_debug_proxy_obj = session_bus.get_object(UNITY_BUS_NAME, DEBUG_PATH)
+_introspection_iface = Interface(_debug_proxy_obj, INTROSPECTION_IFACE)
+
+
+def get_state_by_path(piece='/Unity'):
+    """Returns a full dump of unity's state."""
+    return _introspection_iface.GetState(piece)
+
+
+def get_state_by_name_and_id(class_name, unique_id):
+    """Get a state dictionary from unity given a class name and id.
+
+    raises StateNotFoundError if the state is not found.
+
+    Returns a dictionary of information. Unlike get_state_by_path, this
+    method can never return state for more than one object.
+    """
+    try:
+        query = "//%(class_name)s[id=%(unique_id)d]" % (dict(
+                                                    class_name=class_name,
+                                                    unique_id=unique_id))
+        return get_state_by_path(query)[0]
+    except IndexError:
+        raise StateNotFoundError(class_name, unique_id)
+
+
+def make_introspection_object(dbus_tuple):
+    """Make an introspection object given a DBus tuple of (name, state_dict).
+
+    This only works for classes that derive from UnityIntrospectionObject.
+    """
+    name, state = dbus_tuple
+    try:
+        class_type = _object_registry[name]
+    except KeyError:
+        print name, "is not a valid introspection type!"
+        return None
+    return class_type(state)
+
+
+def start_log_to_file(file_path):
+    """Instruct Unity to start logging to the given file."""
+    _introspection_iface.StartLogToFile(file_path)
+
+
+def reset_logging():
+    """Instruct Unity to stop logging to a file."""
+    _introspection_iface.ResetLogging()
+
+
+def set_log_severity(component, severity):
+    """Instruct Unity to set a log component's severity.
+
+    'component' is the unity logging component name.
+
+    'severity' is the severity name (like 'DEBUG', 'INFO' etc.)
+
+    """
+    _introspection_iface.SetLogSeverity(component, severity)
+
+
+def log_unity_message(severity, message):
+    """Instruct unity to log a message for us.
+
+    severity: one of ('TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR').
+
+    message: The message to log.
+
+    For debugging purposes only! If you want to log a message during an autopilot
+    test, use the python logging framework instead.
+
+    """
+    _introspection_iface.LogMessage(severity, message)
+
+
+def translate_state_keys(state_dict):
+    """Translates the state_dict passed in so the keys are usable as python attributes."""
+    return {k.replace('-','_'):v for k,v in state_dict.iteritems() }
+
+
+class UnityIntrospectionObject(object):
+    """A class that can be created using a dictionary of state from Unity."""
+    __metaclass__ = IntrospectableObjectMetaclass
+
+    def __init__(self, state_dict):
+        self.__state = {}
+        self.set_properties(state_dict)
+
+    def set_properties(self, state_dict):
+        """Creates and set attributes of `self` based on contents of `state_dict`.
+
+        Translates '-' to '_', so a key of 'icon-type' for example becomes 'icon_type'.
+
+        """
+        self.__state = {}
+        for key, value in translate_state_keys(state_dict).iteritems():
+            # don't store id in state dictionary -make it a proper instance attribute
+            if key == 'id':
+                self.id = value
+            self.__state[key] = self._make_attribute(key, value)
+
+    def _make_attribute(self, name, value):
+        """Make an attribute for 'value', patched with the wait_for function."""
+
+        def wait_for(self, expected_value):
+            """Wait up to 10 seconds for our value to change to 'expected_value'.
+
+            expected_value can be a testtools.matcher.Matcher subclass (like
+            LessThan, for example), or an ordinary value.
+
+            This works by refreshing the value using repeated dbus calls.
+
+            Raises RuntimeError if the attribute was not equal to the expected value
+            after 10 seconds.
+
+            """
+            # It's guaranteed that our value is up to date, since __getattr__ calls
+            # refresh_state. This if statement stops us waiting if the value is
+            # already what we expect:
+            if self == expected_value:
+                return
+
+            # unfortunately not all testtools matchers derive from the Matcher
+            # class, so we can't use issubclass, isinstance for this:
+            match_fun = getattr(expected_value, 'match', None)
+            is_matcher = match_fun and callable(match_fun)
+            if not is_matcher:
+                expected_value = Equals(expected_value)
+
+            for i in range(11):
+                new_state = translate_state_keys(get_state_by_name_and_id(
+                                                self.parent.__class__.__name__,
+                                                self.parent.id)
+                                                )
+                new_value = new_state[self.name]
+                # Support for testtools.matcher classes:
+                mismatch = expected_value.match(new_value)
+                if mismatch:
+                    failure_msg = mismatch.describe()
+                else:
+                    self.parent.set_properties(new_state)
+                    return
+
+                sleep(1)
+
+            raise AssertionError("After 10 seconds test on %s.%s failed: %s"
+                % (self.parent.__class__.__name__, self.name, failure_msg))
+
+        # This looks like magic, but it's really not. We're creating a new type
+        # on the fly that derives from the type of 'value' with a couple of
+        # extra attributes: wait_for is the wait_for method above. 'parent' and
+        # 'name' are needed by the wait_for method.
+        #
+        # We can't use traditional meta-classes here, since the type we're
+        # deriving from is only known at call time, not at parse time (we could
+        # override __call__ in the meta class, but that doesn't buy us anything
+        # extra).
+        #
+        # A better way to do this would be with functools.partial, which I tried
+        # initially, but doesn't work well with bound methods.
+        t = type(value)
+        attrs = {'wait_for': wait_for, 'parent':self, 'name':name}
+        return type(t.__name__, (t,), attrs)(value)
+
+    def _get_child_tuples_by_type(self, desired_type):
+        """Get a list of (name,dict) pairs from children of the specified type.
+
+        desired_type must be a subclass of UnityIntrospectionObject.
+
+        """
+        if not issubclass(desired_type, UnityIntrospectionObject):
+            raise TypeError("%r must be a subclass of %r" % (desired_type,
+                UnityIntrospectionObject))
+
+        children = getattr(self, 'Children', [])
+        results = []
+        # loop through all children, and try find one that matches the type the
+        # user wants.
+        for child_type, child_state in children:
+            try:
+                if issubclass(_object_registry[child_type], desired_type):
+                    results.append((child_type, child_state))
+            except KeyError:
+                pass
+        return results
+
+    def get_children_by_type(self, desired_type, **kwargs):
+        """Get a list of children of the specified type.
+
+        desired_type must be a subclass of UnityIntrospectionObject.
+
+        Keyword arguments can be used to restrict returned instances. For example:
+
+        >>> get_children_by_type(Launcher, monitor=1)
+
+        ... will return only LauncherInstances that have an attribute 'monitor'
+            that is equal to 1.
+
+        """
+        self.refresh_state()
+        result = []
+        for child in self._get_child_tuples_by_type(desired_type):
+            instance = make_introspection_object(child)
+            filters_passed = True
+            for attr, val in kwargs.iteritems():
+                if not hasattr(instance, attr) or getattr(instance, attr) != val:
+                    # Either attribute is not present, or is present but with
+                    # the wrong value - don't add this instance to the results list.
+                    filters_passed = False
+                    break
+            if filters_passed:
+                result.append(instance)
+        return result
+
+    def refresh_state(self):
+        """Refreshes the object's state from unity.
+
+        raises StateNotFound if the object in unity has been destroyed.
+
+        """
+        # need to get name from class object.
+        new_state = get_state_by_name_and_id(self.__class__.__name__, self.id)
+        self.set_properties(new_state)
+
+    @classmethod
+    def get_all_instances(cls):
+        """Get all instances of this class that exist within the Unity state tree.
+
+        For example, to get all the BamfLauncherIcons:
+
+        icons = BamfLauncherIcons.get_all_instances()
+
+        The return value is a list (possibly empty) of class instances.
+
+        """
+        cls_name = cls.__name__
+        instances = get_state_by_path("//%s" % (cls_name))
+        return [make_introspection_object((cls_name,i)) for i in instances]
+
+    def __getattr__(self, name):
+        # avoid recursion if for some reason we have no state set (should never)
+        # happen.
+        if name == '__state':
+            raise AttributeError()
+
+        if name in self.__state:
+            self.refresh_state()
+            return self.__state[name]
+        # attribute not found.
+        raise AttributeError("Attribute '%s' not found." % (name))
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/autopilot/unity/emulators/dash.py'
--- tests/autopilot/unity/emulators/dash.py	2012-05-08 16:13:17 +0000
+++ tests/autopilot/unity/emulators/dash.py	2012-05-24 17:16:22 +0000
@@ -7,9 +7,13 @@
 # by the Free Software Foundation.
 #
 
+<<<<<<< TREE
 from __future__ import absolute_import
 
 from autopilot.introspection.unity import (
+=======
+from autopilot.emulators.unity import (
+>>>>>>> MERGE-SOURCE
     get_state_by_path,
     make_introspection_object,
     UnityIntrospectionObject,

=== modified file 'tests/autopilot/unity/emulators/hud.py'
=== modified file 'tests/autopilot/unity/emulators/icons.py'
--- tests/autopilot/unity/emulators/icons.py	2012-05-16 02:57:25 +0000
+++ tests/autopilot/unity/emulators/icons.py	2012-05-24 17:16:22 +0000
@@ -7,11 +7,17 @@
 # by the Free Software Foundation.
 #
 
+<<<<<<< TREE
 from __future__ import absolute_import
 
 from autopilot.introspection.unity import UnityIntrospectionObject
 from unity.emulators.quicklist import Quicklist
 from unity.emulators.tooltip import ToolTip
+=======
+from autopilot.emulators.unity import UnityIntrospectionObject
+from autopilot.emulators.unity.quicklist import Quicklist
+from autopilot.emulators.unity.tooltip import ToolTip
+>>>>>>> MERGE-SOURCE
 
 class SimpleLauncherIcon(UnityIntrospectionObject):
     """Holds information about a simple launcher icon.

=== modified file 'tests/autopilot/unity/emulators/launcher.py'
=== modified file 'tests/autopilot/unity/emulators/quicklist.py'
=== modified file 'tests/autopilot/unity/emulators/shortcut_hint.py'
=== modified file 'tests/autopilot/unity/emulators/tooltip.py'
--- tests/autopilot/unity/emulators/tooltip.py	2012-05-16 02:57:25 +0000
+++ tests/autopilot/unity/emulators/tooltip.py	2012-05-24 17:16:22 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 # Copyright 2012 Canonical
 # Author: Andrea Azzarone
@@ -18,3 +19,25 @@
 
 class ToolTip(UnityIntrospectionObject):
     """Represents a tooltip."""
+=======
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2012 Canonical
+# Author: Andrea Azzarone
+#
+# 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.
+#
+
+import logging
+from time import sleep
+
+from autopilot.emulators.unity import UnityIntrospectionObject
+
+
+logger = logging.getLogger(__name__)
+
+
+class ToolTip(UnityIntrospectionObject):
+    """Represents a tooltip."""
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/autopilot/unity/emulators/window_manager.py'
--- tests/autopilot/unity/emulators/window_manager.py	2012-05-08 16:13:17 +0000
+++ tests/autopilot/unity/emulators/window_manager.py	2012-05-24 17:16:22 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 # Copyright 2012 Canonical
 # Author: Marco Trevisan (Treviño)
@@ -22,3 +23,27 @@
     def screen_geometry(self):
         """Returns a tuple of (x,y,w,h) for the screen."""
         return (self.x, self.y, self.width, self.height)
+=======
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2012 Canonical
+# Author: Marco Trevisan (Treviño)
+#
+# 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.
+#
+
+import logging
+from autopilot.emulators.unity import UnityIntrospectionObject
+
+logger = logging.getLogger(__name__)
+
+
+class WindowManager(UnityIntrospectionObject):
+    """The WindowManager class."""
+
+    @property
+    def screen_geometry(self):
+        """Returns a tuple of (x,y,w,h) for the screen."""
+        return (self.x, self.y, self.width, self.height)
+>>>>>>> MERGE-SOURCE

=== 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-24 17:16:22 +0000
@@ -29,6 +29,7 @@
     start_log_to_file,
     reset_logging,
     )
+<<<<<<< TREE
 
 
 
@@ -94,6 +95,95 @@
         managers = WindowManager.get_all_instances()
         self.assertThat(len(managers), Equals(1))
         return managers[0]
+=======
+from autopilot.emulators.unity.dash import Dash
+from autopilot.emulators.unity.hud import Hud
+from autopilot.emulators.unity.launcher import LauncherController
+from autopilot.emulators.unity.panel import PanelController
+from autopilot.emulators.unity.switcher import Switcher
+from autopilot.emulators.unity.window_manager import WindowManager
+from autopilot.emulators.unity.workspace import WorkspaceManager
+from autopilot.emulators.X11 import ScreenGeometry, Keyboard, Mouse, reset_display
+from autopilot.glibrunner import GlibRunner
+from autopilot.globals import (global_context,
+    video_recording_enabled,
+    video_record_directory,
+    )
+from autopilot.keybindings import KeybindingsHelper
+
+
+logger = logging.getLogger(__name__)
+
+
+try:
+    from testscenarios.scenarios import multiply_scenarios
+except ImportError:
+    from itertools import product
+    def multiply_scenarios(*scenarios):
+        """Multiply two or more iterables of scenarios.
+
+        It is safe to pass scenario generators or iterators.
+
+        :returns: A list of compound scenarios: the cross-product of all
+            scenarios, with the names concatenated and the parameters
+            merged together.
+        """
+        result = []
+        scenario_lists = map(list, scenarios)
+        for combination in product(*scenario_lists):
+            names, parameters = zip(*combination)
+            scenario_name = ','.join(names)
+            scenario_parameters = {}
+            for parameter in parameters:
+                scenario_parameters.update(parameter)
+            result.append((scenario_name, scenario_parameters))
+        return result
+
+
+class LoggedTestCase(TestWithScenarios, TestCase):
+    """Initialize the logging for the test case."""
+
+    def setUp(self):
+        self._setUpTestLogging()
+        self._setUpUnityLogging()
+        # The reason that the super setup is done here is due to making sure
+        # that the logging is properly set up prior to calling it.
+        super(LoggedTestCase, self).setUp()
+
+    def _setUpTestLogging(self):
+        class MyFormatter(logging.Formatter):
+
+            def formatTime(self, record, datefmt=None):
+                ct = self.converter(record.created)
+                if datefmt:
+                    s = time.strftime(datefmt, ct)
+                else:
+                    t = time.strftime("%H:%M:%S", ct)
+                    s = "%s.%03d" % (t, record.msecs)
+                return s
+
+        self._log_buffer = StringIO()
+        root_logger = logging.getLogger()
+        root_logger.setLevel(logging.DEBUG)
+        handler = logging.StreamHandler(stream=self._log_buffer)
+        log_format = "%(asctime)s %(levelname)s %(module)s:%(lineno)d - %(message)s"
+        handler.setFormatter(MyFormatter(log_format))
+        root_logger.addHandler(handler)
+        #Tear down logging in a cleanUp handler, so it's done after all other
+        # tearDown() calls and cleanup handlers.
+        self.addCleanup(self._tearDownLogging)
+
+    def _tearDownLogging(self):
+        logger = logging.getLogger()
+        for handler in logger.handlers:
+            handler.flush()
+            self._log_buffer.seek(0)
+            self.addDetail('test-log', text_content(self._log_buffer.getvalue()))
+            logger.removeHandler(handler)
+        # Calling del to remove the handler and flush the buffer.  We are
+        # abusing the log handlers here a little.
+        del self._log_buffer
+>>>>>>> MERGE-SOURCE
 
     def _setUpUnityLogging(self):
         self._unity_log_file_name = mktemp(prefix=self.shortDescription())
@@ -122,3 +212,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_command_lens.py'
--- tests/autopilot/unity/tests/test_command_lens.py	2012-05-08 16:13:17 +0000
+++ tests/autopilot/unity/tests/test_command_lens.py	2012-05-24 17:16:22 +0000
@@ -12,10 +12,18 @@
 from testtools.matchers import Equals
 from time import sleep
 
+<<<<<<< TREE
 from unity.tests import UnityTestCase
 
 
 class CommandLensSearchTests(UnityTestCase):
+=======
+from autopilot.tests import AutopilotTestCase
+from autopilot.matchers import Eventually
+
+
+class CommandLensSearchTests(AutopilotTestCase):
+>>>>>>> MERGE-SOURCE
     """Test the command lense search bahavior."""
 
     def setUp(self):

=== modified file 'tests/autopilot/unity/tests/test_dash.py'
--- tests/autopilot/unity/tests/test_dash.py	2012-05-08 16:13:17 +0000
+++ tests/autopilot/unity/tests/test_dash.py	2012-05-24 17:16:22 +0000
@@ -12,12 +12,22 @@
 
 from autopilot.matchers import Eventually
 from gtk import Clipboard
+<<<<<<< TREE
 from testtools.matchers import Equals, NotEquals
 
 from unity.tests import UnityTestCase
 
 
 class DashTestCase(UnityTestCase):
+=======
+from testtools.matchers import Equals, NotEquals
+
+from autopilot.matchers import Eventually
+from autopilot.tests import AutopilotTestCase
+
+
+class DashTestCase(AutopilotTestCase):
+>>>>>>> MERGE-SOURCE
     def setUp(self):
         super(DashTestCase, self).setUp()
         self.set_unity_log_level("unity.shell", "DEBUG")

=== modified file 'tests/autopilot/unity/tests/test_home_lens.py'
--- tests/autopilot/unity/tests/test_home_lens.py	2012-05-08 16:13:17 +0000
+++ tests/autopilot/unity/tests/test_home_lens.py	2012-05-24 17:16:22 +0000
@@ -6,16 +6,28 @@
 # under the terms of the GNU General Public License version 3, as published
 # by the Free Software Foundation.
 
+<<<<<<< TREE
 from __future__ import absolute_import
 
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals
+=======
+from testtools.matchers import Equals
+>>>>>>> MERGE-SOURCE
 from time import sleep
 
+<<<<<<< TREE
 from unity.tests import UnityTestCase
 
 
 class HomeLensSearchTests(UnityTestCase):
+=======
+from autopilot.matchers import Eventually
+from autopilot.tests import AutopilotTestCase
+
+
+class HomeLensSearchTests(AutopilotTestCase):
+>>>>>>> MERGE-SOURCE
     """Test the command lense search bahavior."""
 
     def setUp(self):

=== modified file 'tests/autopilot/unity/tests/test_hud.py'
--- tests/autopilot/unity/tests/test_hud.py	2012-05-08 16:13:17 +0000
+++ tests/autopilot/unity/tests/test_hud.py	2012-05-24 17:16:22 +0000
@@ -7,6 +7,7 @@
 # under the terms of the GNU General Public License version 3, as published
 # by the Free Software Foundation.
 
+<<<<<<< TREE
 from __future__ import absolute_import
 
 from autopilot.matchers import Eventually
@@ -20,10 +21,28 @@
     LessThan,
     NotEquals,
     )
+=======
+from os import remove
+from testtools.matchers import (
+    Equals,
+    EndsWith,
+    GreaterThan,
+    LessThan,
+    NotEquals,
+    )
+>>>>>>> MERGE-SOURCE
 from time import sleep
 
+<<<<<<< TREE
 from unity.emulators.icons import HudLauncherIcon
 from unity.tests import UnityTestCase
+=======
+from autopilot.emulators.unity.icons import HudLauncherIcon
+from autopilot.emulators.X11 import ScreenGeometry
+from autopilot.matchers import Eventually
+from autopilot.tests import AutopilotTestCase, multiply_scenarios
+
+>>>>>>> MERGE-SOURCE
 
 
 def _make_monitor_scenarios():
@@ -208,9 +227,15 @@
         """When switching from the hud to the dash alt+f1 is disabled."""
         self.hud.ensure_visible()
         self.dash.ensure_visible()
+<<<<<<< TREE
         self.addCleanup(self.dash.ensure_hidden)
 
         self.keybinding("launcher/keynav")
+=======
+        self.addCleanup(self.dash.ensure_hidden)
+    
+        self.keybinding("launcher/keynav")
+>>>>>>> MERGE-SOURCE
         self.assertThat(self.launcher.key_nav_is_active, Equals(False))
 
     def test_hud_to_dash_has_key_focus(self):

=== modified file 'tests/autopilot/unity/tests/test_ibus.py'
--- tests/autopilot/unity/tests/test_ibus.py	2012-05-16 02:57:25 +0000
+++ tests/autopilot/unity/tests/test_ibus.py	2012-05-24 17:16:22 +0000
@@ -8,13 +8,18 @@
 
 """Tests to ensure unity is compatible with ibus input method."""
 
+<<<<<<< TREE
 from __future__ import absolute_import
+=======
+from testtools.matchers import Equals, NotEquals
+>>>>>>> MERGE-SOURCE
 
 from autopilot.emulators.ibus import (
     get_active_input_engines,
     set_active_engines,
     get_available_input_engines,
     )
+<<<<<<< TREE
 from autopilot.matchers import Eventually
 from autopilot.testcase import multiply_scenarios
 from testtools.matchers import Equals, NotEquals
@@ -23,6 +28,13 @@
 
 
 class IBusTests(UnityTestCase):
+=======
+from autopilot.matchers import Eventually
+from autopilot.tests import AutopilotTestCase, multiply_scenarios
+
+
+class IBusTests(AutopilotTestCase):
+>>>>>>> MERGE-SOURCE
     """Base class for IBus tests."""
 
     def setUp(self):
@@ -31,6 +43,7 @@
     def tearDown(self):
         super(IBusTests, self).tearDown()
 
+<<<<<<< TREE
     @classmethod
     def setUpClass(cls):
         cls._old_engines = None
@@ -41,11 +54,30 @@
             set_active_engines(cls._old_engines)
 
     def activate_input_engine_or_skip(self, engine_name):
+=======
+    @classmethod
+    def setUpClass(cls):
+        cls._old_engines = None
+        cls.activate_input_engine_or_skip(cls.engine_name)
+
+    @classmethod
+    def tearDownClass(cls):
+        if cls._old_engines is not None:
+            set_active_engines(cls._old_engines)
+
+    @classmethod
+    def activate_input_engine_or_skip(cls, engine_name):
+>>>>>>> MERGE-SOURCE
         available_engines = get_available_input_engines()
         if engine_name in available_engines:
+<<<<<<< TREE
             if get_active_input_engines() != [engine_name]:
                 IBusTests._old_engines = set_active_engines([engine_name])
+=======
+            cls._old_engines = set_active_engines([engine_name])
+>>>>>>> MERGE-SOURCE
         else:
+<<<<<<< TREE
             self.skip("This test requires the '%s' engine to be installed." % (engine_name))
 
     def activate_ibus(self, widget):
@@ -81,6 +113,43 @@
             self.keyboard.press_and_release(commit_key)
         self.deactivate_ibus(self.hud.searchbar)
         self.assertThat(self.hud.search_string, Eventually(Equals(self.result)))
+=======
+            raise AutopilotTestCase.skipException("This test requires the '%s' engine to be installed." % (engine_name))
+
+    def activate_ibus(self, widget):
+        """Activate IBus, and wait till it's actived on 'widget'"""
+        self.assertThat(widget.im_active, Equals(False))
+        self.keyboard.press_and_release('Ctrl+Space', 0.05)
+        self.assertThat(widget.im_active, Eventually(Equals(True)))
+
+    def deactivate_ibus(self, widget):
+        """Deactivate ibus, and wait till it's inactive on 'widget'"""
+        self.assertThat(widget.im_active, Equals(True))
+        self.keyboard.press_and_release('Ctrl+Space', 0.05)
+        self.assertThat(widget.im_active, Eventually(Equals(False)))
+
+    def do_dash_test_with_engine(self):
+        self.dash.ensure_visible()
+        self.addCleanup(self.dash.ensure_hidden)
+        self.activate_ibus(self.dash.searchbar)
+        self.keyboard.type(self.input)
+        commit_key = getattr(self, 'commit_key', None)
+        if commit_key:
+            self.keyboard.press_and_release(commit_key)
+        self.deactivate_ibus(self.dash.searchbar)
+        self.assertThat(self.dash.search_string, Eventually(Equals(self.result)))
+
+    def do_hud_test_with_engine(self):
+        self.hud.ensure_visible()
+        self.addCleanup(self.hud.ensure_hidden)
+        self.activate_ibus(self.hud.searchbar)
+        self.keyboard.type(self.input)
+        commit_key = getattr(self, 'commit_key', None)
+        if commit_key:
+            self.keyboard.press_and_release(commit_key)
+        self.deactivate_ibus(self.hud.searchbar)
+        self.assertThat(self.hud.search_string, Eventually(Equals(self.result)))
+>>>>>>> MERGE-SOURCE
 
 
 class IBusTestsPinyin(IBusTests):
@@ -160,12 +229,17 @@
 class IBusTestsPinyinIgnore(IBusTests):
     """Tests for ignoring key events while the Pinyin input engine is active."""
 
+<<<<<<< TREE
     engine_name = "pinyin"
 
     def setUp(self):
         super(IBusTestsPinyinIgnore, self).setUp()
         self.activate_input_engine_or_skip(self.engine_name)
 
+=======
+    engine_name = "pinyin"
+
+>>>>>>> MERGE-SOURCE
     def test_ignore_key_events_on_dash(self):
         self.dash.ensure_visible()
         self.addCleanup(self.dash.ensure_hidden)
@@ -194,12 +268,17 @@
 class IBusTestsAnthyIgnore(IBusTests):
     """Tests for ignoring key events while the Anthy input engine is active."""
 
+<<<<<<< TREE
     engine_name = "anthy"
 
     def setUp(self):
         super(IBusTestsAnthyIgnore, self).setUp()
         self.activate_input_engine_or_skip(self.engine_name)
 
+=======
+    engine_name = "anthy"
+
+>>>>>>> MERGE-SOURCE
     def test_ignore_key_events_on_dash(self):
         self.dash.ensure_visible()
         self.addCleanup(self.dash.ensure_hidden)

=== 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-24 17:16:22 +0000
@@ -19,9 +19,17 @@
 from testtools.matchers import Equals, NotEquals, LessThan, GreaterThan
 from time import sleep
 
+<<<<<<< TREE
 from unity.emulators.icons import BFBLauncherIcon
 from unity.emulators.switcher import SwitcherMode
 from unity.tests import UnityTestCase
+=======
+from autopilot.emulators.bamf import Bamf
+from autopilot.emulators.unity.icons import BFBLauncherIcon
+from autopilot.emulators.X11 import ScreenGeometry
+from autopilot.matchers import Eventually
+from autopilot.tests import AutopilotTestCase, multiply_scenarios
+>>>>>>> MERGE-SOURCE
 
 logger = logging.getLogger(__name__)
 
@@ -41,8 +49,13 @@
                                 ('launcher on all', {'only_primary': False})]
     return multiply_scenarios(monitor_scenarios, launcher_mode_scenarios)
 
+<<<<<<< TREE
 
 class LauncherTestCase(UnityTestCase):
+=======
+
+class LauncherTestCase(AutopilotTestCase):
+>>>>>>> MERGE-SOURCE
     """A base class for all launcher tests that uses scenarios to run on
     each launcher (for multi-monitor setups).
     """
@@ -381,9 +394,15 @@
     def test_launcher_keynav_alt_grave_quits(self):
         """Tests that alt+` exits keynav mode."""
 
+<<<<<<< TREE
         # Can't use switcher emulat here since the switcher won't appear.
         self.keybinding("switcher/reveal_details")
         self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False)))
+=======
+        self.switcher.initiate_detail_mode()
+        self.addCleanup(self.switcher.terminate)
+        self.assertThat(self.launcher.key_nav_is_active, Eventually(Equals(False)))
+>>>>>>> MERGE-SOURCE
 
 
 class LauncherIconsBehaviorTests(LauncherTestCase):
@@ -586,6 +605,7 @@
         self.mouse.move(x + w/2, y + h/2)
         sleep(.5)
         for icon in self.launcher.model.get_launcher_icons():
+<<<<<<< TREE
             self.assertThat(icon.desaturated, Eventually(Equals(False)))
 
 class BamfDaemonTests(LauncherTestCase):
@@ -685,6 +705,107 @@
 
 
 class LauncherCaptureTests(UnityTestCase):
+=======
+            self.assertThat(icon.desaturated, Eventually(Equals(False)))
+
+class BamfDaemonTests(LauncherTestCase):
+    """Test interaction between the launcher and the BAMF Daemon."""
+
+    def start_test_apps(self):
+        """Starts some test applications."""
+        self.start_app("Calculator")
+        self.start_app("System Settings")
+
+    def start_desktopless_test_apps(self):
+        """Start test applications with no .desktop file associated."""
+        test_apps = ["xclock"]
+
+        for app in test_apps:
+            os.spawnlp(os.P_NOWAIT, app, app)
+            self.addCleanup(call, ["killall", app])
+            self.wait_for_process_started(app)
+
+    def get_test_apps(self):
+        """Return a tuple of test application instances.
+
+        We don't store these since when we kill the bamf daemon all references
+        to the old apps will die.
+
+        """
+        [calc] = self.get_app_instances("Calculator")
+        [sys_settings] = self.get_app_instances("System Settings")
+        return [calc, sys_settings]
+
+    def get_desktopless_test_apps(self):
+        """Return a tuple of test application with no .desktop files instances."""
+        [xclock_win] = [w for w in self.bamf.get_open_windows() if w.name == "xclock"]
+        return [xclock_win.application]
+
+    def assertOnlyOneLauncherIcon(self, **kwargs):
+        """Asserts that there is only one launcher icon with the given filter."""
+        icons = self.launcher.model.get_icons_by_filter(**kwargs)
+        self.assertThat(len(icons), Equals(1))
+
+    def wait_for_process_started(self, app):
+        """Wait until the application app has been started."""
+        for i in range(10):
+            sleep(1)
+            #pgrep returns 0 if it matched something:
+            if call(["pgrep", app]) == 0:
+                return
+
+    def wait_for_process_killed(self, app):
+        """Wait until the application app has been killed."""
+        for i in range(10):
+            #pgrep returns 0 if it matched something:
+            if call(["pgrep", app]) != 0:
+                return
+            sleep(1)
+
+    def kill_and_restart_bamfdaemon(self):
+        """Kills and resumes bamfdaemon."""
+        call(["pkill", "bamfdaemon"])
+        self.wait_for_process_killed("bamfdaemon")
+
+        # trigger the bamfdaemon to be reloaded again, and wait for it to appear:
+        self.bamf = Bamf()
+        self.wait_for_process_started("bamfdaemon")
+
+    def test_killing_bamfdaemon_does_not_duplicate_desktop_ids(self):
+        """Killing bamfdaemon should not duplicate any desktop ids in the model."""
+        self.start_test_apps()
+        self.kill_and_restart_bamfdaemon()
+
+        for test_app in self.get_test_apps():
+            logger.info("Checking for duplicated launcher icon for application %s", test_app.name)
+            self.assertOnlyOneLauncherIcon(desktop_id=test_app.desktop_file)
+
+    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()
@@ -783,6 +904,7 @@
         x_fin, y_fin = self.mouse.position()
         # The launcher should have held the mouse a little bit
         self.assertThat(x_fin, LessThan(x + width * 1.5))
+<<<<<<< TREE
 
 
 class LauncherTooltipTests(UnityTestCase):
@@ -811,3 +933,33 @@
          self.mouse.move(bfb.center_x, bfb.center_y)
 
          self.assertThat(bfb.get_tooltip().active, Eventually(Equals(False)))
+=======
+
+
+class LauncherTooltipTests(AutopilotTestCase):
+    """Test the launcher tooltips"""
+
+    def setUp(self):
+        super(LauncherTooltipTests, self).setUp()
+        self.set_unity_option('launcher_hide_mode', 0)
+
+    def test_bfb_tooltip_disappear_when_dash_is_opened(self):
+         """Tests that the bfb tooltip disappear when the dash is opened."""
+         bfb = self.launcher.model.get_bfb_icon()
+         self.mouse.move(bfb.center_x, bfb.center_y)
+
+         self.dash.ensure_visible()
+         self.addCleanup(self.dash.ensure_hidden)
+
+         self.assertThat(bfb.get_tooltip().active, Eventually(Equals(False)))
+
+    def test_bfb_tooltip_is_disabled_when_dash_is_open(self):
+         """Tests the that bfb tooltip is disabled when the dash is open."""
+         self.dash.ensure_visible()
+         self.addCleanup(self.dash.ensure_hidden)
+
+         bfb = self.launcher.model.get_bfb_icon()
+         self.mouse.move(bfb.center_x, bfb.center_y)
+
+         self.assertThat(bfb.get_tooltip().active, Eventually(Equals(False)))
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/autopilot/unity/tests/test_panel.py'
--- tests/autopilot/unity/tests/test_panel.py	2012-05-08 16:13:17 +0000
+++ tests/autopilot/unity/tests/test_panel.py	2012-05-24 17:16:22 +0000
@@ -19,6 +19,7 @@
 from unity.tests import UnityTestCase
 
 
+
 logger = logging.getLogger(__name__)
 
 

=== modified file 'tests/autopilot/unity/tests/test_quicklist.py'
--- tests/autopilot/unity/tests/test_quicklist.py	2012-05-17 23:16:25 +0000
+++ tests/autopilot/unity/tests/test_quicklist.py	2012-05-24 17:16:22 +0000
@@ -13,6 +13,7 @@
 import os.path
 from testtools.matchers import Contains, Equals, NotEquals
 from xdg.DesktopEntry import DesktopEntry
+<<<<<<< TREE
 from time import sleep
 
 from unity.emulators.quicklist import QuicklistMenuItemLabel
@@ -20,12 +21,23 @@
 
 
 class QuicklistActionTests(UnityTestCase):
+=======
+from time import sleep
+
+from autopilot.emulators.unity.quicklist import QuicklistMenuItemLabel
+from autopilot.matchers import Eventually
+from autopilot.tests import AutopilotTestCase
+
+
+class QuicklistActionTests(AutopilotTestCase):
+>>>>>>> MERGE-SOURCE
     """Tests for quicklist actions."""
 
     scenarios = [
         ('remmina', {'app_name': 'Remmina'}),
     ]
 
+<<<<<<< TREE
     def open_quicklist_for_icon(self, launcher_icon):
         """Open the quicklist for the given launcher icon.
 
@@ -41,6 +53,13 @@
                 return ql
             sleep(1)
 
+=======
+    def open_quicklist_for_icon(self, launcher_icon):
+        launcher = self.launcher.get_launcher_for_monitor(0)
+        launcher.click_launcher_icon(launcher_icon, button=3)
+        self.addCleanup(self.keyboard.press_and_release, "Escape")
+
+>>>>>>> MERGE-SOURCE
     def test_quicklist_actions(self):
         """Test that all actions present in the destop file are shown in the quicklist."""
         self.start_app(self.app_name)
@@ -54,7 +73,12 @@
         self.assertThat(launcher_icon, NotEquals(None))
 
         # open the icon quicklist, and get all the text labels:
+<<<<<<< TREE
         ql = self.open_quicklist_for_icon(launcher_icon)
+=======
+        self.open_quicklist_for_icon(launcher_icon)
+        ql = launcher_icon.get_quicklist()
+>>>>>>> MERGE-SOURCE
         ql_item_texts = [i.text for i in ql.items if type(i) is QuicklistMenuItemLabel]
 
         # iterate over all the actions from the desktop file, make sure they're
@@ -67,6 +91,7 @@
             name = de.content[key]['Name']
             self.assertThat(ql_item_texts, Contains(name))
 
+<<<<<<< TREE
     def test_quicklist_application_item_focus_last_active_window(self):
         """This tests shows that when you activate a quicklist application item
         only the last focused instance of that application is rasied.
@@ -335,3 +360,276 @@
         mouse_item.mouse_move_to()
         self.assertThat(mouse_item.selected, Eventually(Equals(True)))
         self.assertThat(self.quicklist.selected_item.id, Equals(mouse_item.id))
+=======
+    def test_quicklist_application_item_focus_last_active_window(self):
+        """This tests shows that when you activate a quicklist application item
+        only the last focused instance of that application is rasied.
+
+        This is tested by opening 2 Mahjongg and a Calculator.
+        Then we activate the Calculator quicklist item.
+        Then we actiavte the Mahjongg launcher icon.
+        """
+        mahj = self.start_app("Mahjongg")
+        [mah_win1] = mahj.get_windows()
+        self.assertTrue(mah_win1.is_focused)
+
+        calc = self.start_app("Calculator")
+        [calc_win] = calc.get_windows()
+        self.assertTrue(calc_win.is_focused)
+
+        self.start_app("Mahjongg")
+        # Sleeping due to the start_app only waiting for the bamf model to be
+        # updated with the application.  Since the app has already started,
+        # and we are just waiting on a second window, however a defined sleep
+        # here is likely to be problematic.
+        # TODO: fix bamf emulator to enable waiting for new windows.
+        sleep(1)
+        [mah_win2] = [w for w in mahj.get_windows() if w.x_id != mah_win1.x_id]
+        self.assertTrue(mah_win2.is_focused)
+
+        self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
+
+        mahj_icon = self.launcher.model.get_icon_by_desktop_id(mahj.desktop_file)
+        calc_icon = self.launcher.model.get_icon_by_desktop_id(calc.desktop_file)
+
+        self.open_quicklist_for_icon(calc_icon)
+        calc_ql = calc_icon.get_quicklist()
+        calc_ql.get_quicklist_application_item(calc.name).mouse_click()
+        sleep(1)
+        self.assertTrue(calc_win.is_focused)
+        self.assertVisibleWindowStack([calc_win, mah_win2, mah_win1])
+
+        self.open_quicklist_for_icon(mahj_icon)
+        mahj_ql = mahj_icon.get_quicklist()
+        mahj_ql.get_quicklist_application_item(mahj.name).mouse_click()
+        sleep(1)
+        self.assertTrue(mah_win2.is_focused)
+        self.assertVisibleWindowStack([mah_win2, calc_win, mah_win1])
+
+    def test_quicklist_application_item_initiate_spread(self):
+        """This tests shows that when you activate a quicklist application item
+        when an application window is focused, the spread is initiated.
+        """
+        calc = self.start_app("Calculator")
+        [calc_win1] = calc.get_windows()
+        self.assertTrue(calc_win1.is_focused)
+
+        self.start_app("Calculator")
+        # Sleeping due to the start_app only waiting for the bamf model to be
+        # updated with the application.  Since the app has already started,
+        # and we are just waiting on a second window, however a defined sleep
+        # here is likely to be problematic.
+        # TODO: fix bamf emulator to enable waiting for new windows.
+        sleep(1)
+        [calc_win2] = [w for w in calc.get_windows() if w.x_id != calc_win1.x_id]
+
+        self.assertVisibleWindowStack([calc_win2, calc_win1])
+        self.assertTrue(calc_win2.is_focused)
+
+        calc_icon = self.launcher.model.get_icon_by_desktop_id(calc.desktop_file)
+
+        self.open_quicklist_for_icon(calc_icon)
+        calc_ql = calc_icon.get_quicklist()
+        app_item = calc_ql.get_quicklist_application_item(calc.name)
+
+        self.addCleanup(self.keybinding, "spread/cancel")
+        app_item.mouse_click()
+        self.assertThat(self.window_manager.scale_active, Eventually(Equals(True)))
+        self.assertThat(self.window_manager.scale_active_for_group, Eventually(Equals(True)))
+
+
+class QuicklistKeyNavigationTests(AutopilotTestCase):
+    """Tests for the quicklist key navigation."""
+
+    def setUp(self):
+        super(QuicklistKeyNavigationTests, self).setUp()
+
+        self.ql_app = self.start_app("Text Editor")
+
+        self.ql_launcher_icon = self.launcher.model.get_icon_by_desktop_id(self.ql_app.desktop_file)
+        self.assertThat(self.ql_launcher_icon, NotEquals(None))
+
+        self.ql_launcher = self.launcher.get_launcher_for_monitor(0)
+
+    def open_quicklist_with_mouse(self):
+        """Opens a quicklist with the mouse."""
+        self.ql_launcher.click_launcher_icon(self.ql_launcher_icon, button=3)
+        self.addCleanup(self.keyboard.press_and_release, "Escape")
+        self.quicklist = self.ql_launcher_icon.get_quicklist()
+        self.assertThat(self.quicklist, NotEquals(None))
+        self.quicklist.move_mouse_to_right()
+        self.assertThat(self.quicklist.selected_item, Equals(None))
+
+    def open_quicklist_with_keyboard(self):
+        """Opens a quicklist using the keyboard."""
+        self.screen_geo.move_mouse_to_monitor(0)
+        self.ql_launcher.key_nav_start()
+        self.addCleanup(self.ql_launcher.key_nav_cancel)
+
+        for icon in self.launcher.model.get_launcher_icons():
+            if icon.tooltip_text != self.ql_app.name:
+                self.ql_launcher.key_nav_next()
+            else:
+                self.keybinding("launcher/keynav/open-quicklist")
+                self.addCleanup(self.keybinding, "launcher/keynav/close-quicklist")
+                break
+
+        self.quicklist = self.ql_launcher_icon.get_quicklist()
+        self.assertThat(self.quicklist, NotEquals(None))
+        self.assertThat(self.quicklist.selected_item, NotEquals(None))
+
+    def test_keynav_selects_first_item_when_unselected(self):
+        """Home key MUST select the first selectable item in a quicklist."""
+        self.open_quicklist_with_mouse()
+
+        self.keybinding("quicklist/keynav/first")
+
+        expected_item = self.quicklist.selectable_items[0]
+        self.assertThat(expected_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(expected_item.id))
+
+    def test_keynav_selects_first_item_when_selected(self):
+        """Home key MUST select the first selectable item in a quicklist when
+        another item is selected.
+        """
+        self.open_quicklist_with_mouse()
+        mouse_item = self.quicklist.selectable_items[-1]
+        mouse_item.mouse_move_to()
+        self.assertThat(mouse_item.selected, Eventually(Equals(True)))
+
+        self.keybinding("quicklist/keynav/first")
+
+        expected_item = self.quicklist.selectable_items[0]
+        self.assertThat(expected_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(expected_item.id))
+
+    def test_keynav_next_selects_first_item_when_unselected(self):
+        """Down key MUST select the first valid item when nothing is selected."""
+        self.open_quicklist_with_mouse()
+
+        self.keybinding("quicklist/keynav/next")
+
+        expected_item = self.quicklist.selectable_items[0]
+        self.assertThat(expected_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(expected_item.id))
+
+    def test_keynav_selects_last_item_when_unselected(self):
+        """End key MUST select the last selectable item in a quicklist."""
+        self.open_quicklist_with_mouse()
+
+        self.keybinding("quicklist/keynav/last")
+
+        expected_item = self.quicklist.selectable_items[-1]
+        self.assertThat(expected_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(expected_item.id))
+
+    def test_keynav_selects_last_item_when_selected(self):
+        """End key MUST select the last selectable item in a quicklist when
+        another item is selected.
+        """
+        self.open_quicklist_with_mouse()
+        mouse_item = self.quicklist.selectable_items[0]
+        mouse_item.mouse_move_to()
+        self.assertThat(mouse_item.selected, Eventually(Equals(True)))
+
+        self.keybinding("quicklist/keynav/last")
+
+        expected_item = self.quicklist.selectable_items[-1]
+        self.assertThat(expected_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(expected_item.id))
+
+    def test_keynav_prev_selects_last_item_when_unselected(self):
+        """Up key MUST select the last valid item when nothing is selected."""
+        self.open_quicklist_with_mouse()
+
+        self.keybinding("quicklist/keynav/prev")
+
+        expected_item = self.quicklist.selectable_items[-1]
+        self.assertThat(expected_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(expected_item.id))
+
+    def test_launcher_keynav_selects_first_item(self):
+        """The first selectable item of the quicklist must be selected when
+        opening the quicklist using the launcher key navigation.
+        """
+        self.open_quicklist_with_keyboard()
+
+        expected_item = self.quicklist.selectable_items[0]
+        self.assertThat(expected_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(expected_item.id))
+
+    def test_keynav_next_selection_works(self):
+        """Down key MUST select the next valid item."""
+        self.open_quicklist_with_mouse()
+
+        for item in self.quicklist.selectable_items:
+            self.keybinding("quicklist/keynav/next")
+            self.assertThat(item.selected, Eventually(Equals(True)))
+            self.assertThat(self.quicklist.selected_item.id, Equals(item.id))
+
+    def test_keynav_prev_selection_works(self):
+        """Up key MUST select the previous valid item."""
+        self.open_quicklist_with_mouse()
+
+        for item in reversed(self.quicklist.selectable_items):
+            self.keybinding("quicklist/keynav/prev")
+            self.assertThat(item.selected, Eventually(Equals(True)))
+            self.assertThat(self.quicklist.selected_item.id, Equals(item.id))
+
+    def test_keynav_prev_is_cyclic(self):
+        """Up key MUST select the last item, when the first one is selected."""
+        self.open_quicklist_with_mouse()
+
+        mouse_item = self.quicklist.selectable_items[0]
+        mouse_item.mouse_move_to()
+        self.assertThat(mouse_item.selected, Eventually(Equals(True)))
+
+        self.keybinding("quicklist/keynav/prev")
+        expected_item = self.quicklist.selectable_items[-1]
+        self.assertThat(expected_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(expected_item.id))
+
+    def test_keynav_next_is_cyclic(self):
+        """Down key MUST select the first item, when the last one is selected."""
+        self.open_quicklist_with_mouse()
+
+        mouse_item = self.quicklist.selectable_items[-1]
+        mouse_item.mouse_move_to()
+        self.assertThat(mouse_item.selected, Eventually(Equals(True)))
+
+        self.keybinding("quicklist/keynav/next")
+        expected_item = self.quicklist.selectable_items[0]
+        self.assertThat(expected_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(expected_item.id))
+
+    def test_keynav_mouse_interaction(self):
+        """Tests that the interaction between key-navigation and mouse works as
+        expected. See bug #911561.
+        """
+        self.open_quicklist_with_mouse()
+        mouse_item = self.quicklist.selectable_items[-1]
+        mouse_item.mouse_move_to()
+        self.assertThat(mouse_item.selected, Eventually(Equals(True)))
+
+        self.keybinding("quicklist/keynav/prev")
+        sleep(.1)
+        self.keybinding("quicklist/keynav/prev")
+
+        key_item = self.quicklist.selectable_items[-3]
+        self.assertThat(key_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(key_item.id))
+
+        # Moving the mouse horizontally doesn't change the selection
+        self.mouse.move(mouse_item.x + mouse_item.width - 10, mouse_item.y + mouse_item.height / 2)
+        self.assertThat(self.quicklist.selected_item.id, Equals(key_item.id))
+
+        # Moving the mouse outside doesn't change the selection
+        self.mouse.move(mouse_item.x + mouse_item.width + 50, mouse_item.y + mouse_item.height / 2)
+        self.assertThat(self.quicklist.selected_item.id, Equals(key_item.id))
+
+        # Moving the mouse to another entry, changes the selection
+        mouse_item = self.quicklist.selectable_items[-2]
+        mouse_item.mouse_move_to()
+        self.assertThat(mouse_item.selected, Eventually(Equals(True)))
+        self.assertThat(self.quicklist.selected_item.id, Equals(mouse_item.id))
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/autopilot/unity/tests/test_shortcut_hint.py'
--- tests/autopilot/unity/tests/test_shortcut_hint.py	2012-05-17 11:52:32 +0000
+++ tests/autopilot/unity/tests/test_shortcut_hint.py	2012-05-24 17:16:22 +0000
@@ -12,11 +12,21 @@
 from testtools.matchers import Equals
 from time import sleep
 
+<<<<<<< TREE
 from unity.emulators.shortcut_hint import ShortcutController
 from unity.tests import UnityTestCase
 
 
 class BaseShortcutHintTests(UnityTestCase):
+=======
+from autopilot.emulators.unity.shortcut_hint import ShortcutController
+from autopilot.matchers import Eventually
+from autopilot.tests import AutopilotTestCase
+
+
+
+class BaseShortcutHintTests(AutopilotTestCase):
+>>>>>>> MERGE-SOURCE
     """Base class for the shortcut hint tests"""
 
     def setUp(self):

=== modified file 'tests/test-gesture-engine/CMakeLists.txt'
=== added file 'tests/test_resultviewgrid.cpp'
--- tests/test_resultviewgrid.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_resultviewgrid.cpp	2012-05-24 17:16:22 +0000
@@ -0,0 +1,103 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Andrea Azzarone <[e-mail]>
+ *
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+using namespace testing;
+
+#include "ResultViewGrid.h"
+using namespace unity;
+
+namespace
+{
+
+class MockResultViewGrid : public dash::ResultViewGrid
+{
+public:
+  MockResultViewGrid(NUX_FILE_LINE_DECL) : dash::ResultViewGrid(NUX_FILE_LINE_PARAM) {}
+
+  MOCK_METHOD0(QueueDraw, void());
+  MOCK_METHOD2(GetIndexAtPosition, uint(int x, int y));
+
+  void FakeMouseMoveSignal(int x = 0, int y = 0, int dx = 0, int dy = 0, unsigned long mouse_button_state = 0, unsigned long special_keys_state = 0)
+  {
+    EmitMouseMoveSignal(x, y, dy, dy, mouse_button_state, special_keys_state);
+  }
+};
+
+class TestResultViewGrid : public Test
+{
+public:
+  virtual void SetUp()
+  {
+    view.Adopt(new MockResultViewGrid(NUX_TRACKER_LOCATION));
+    renderer.Adopt(new dash::ResultRenderer(NUX_TRACKER_LOCATION));
+
+    view->SetModelRenderer(renderer.GetPointer());
+    nux::GetWindowCompositor().SetKeyFocusArea(view.GetPointer());
+  }
+
+  nux::ObjectPtr<MockResultViewGrid> view;
+  nux::ObjectPtr<dash::ResultRenderer> renderer;
+};
+
+
+TEST_F(TestResultViewGrid, TestQueueDrawMouseMoveInsideUnfocusedIcon)
+{
+  EXPECT_CALL(*view, QueueDraw())
+    .Times(1);
+
+  EXPECT_CALL(*view, GetIndexAtPosition(_, _))
+    .WillOnce(Return(7));
+
+  view->FakeMouseMoveSignal();
+}
+
+
+TEST_F(TestResultViewGrid, TestQueueDrawMouseMoveInsideFocusedIcon)
+{
+  EXPECT_CALL(*view, GetIndexAtPosition(_, _))
+    .WillRepeatedly(Return(7));
+
+  view->FakeMouseMoveSignal();
+
+  EXPECT_CALL(*view, QueueDraw())
+    .Times(0);
+
+  view->FakeMouseMoveSignal();
+}
+
+
+TEST_F(TestResultViewGrid, TestQueueDrawMouseMoveOutside)
+{
+  EXPECT_CALL(*view, GetIndexAtPosition(_, _))
+    .WillRepeatedly(Return(-1));
+
+  view->FakeMouseMoveSignal();
+
+  EXPECT_CALL(*view, QueueDraw())
+    .Times(0);
+
+  view->FakeMouseMoveSignal();
+}
+
+}

=== renamed file 'tests/test_resultviewgrid.cpp' => 'tests/test_resultviewgrid.cpp.moved'
=== modified file 'unity-shared/DashStyle.cpp'
=== modified file 'unity-shared/DashStyle.h'
=== modified file 'unity-shared/IconTexture.h'
=== modified file 'unity-shared/OverlayRenderer.cpp'
--- unity-shared/OverlayRenderer.cpp	2012-05-22 10:15:47 +0000
+++ unity-shared/OverlayRenderer.cpp	2012-05-24 17:16:22 +0000
@@ -378,8 +378,13 @@
   bool paint_blur = BackgroundEffectHelper::blur_type != BLUR_NONE;
   nux::Geometry geo(content_geo);
 
+<<<<<<< TREE
   int excess_border = (Settings::Instance().GetFormFactor() != FormFactor::NETBOOK || force_edges) ? EXCESS_BORDER : 0;
 
+=======
+  int excess_border = (dash::Settings::Instance().GetFormFactor() != dash::FormFactor::NETBOOK || force_edges) ? EXCESS_BORDER : 0;
+
+>>>>>>> MERGE-SOURCE
   nux::Geometry larger_content_geo = content_geo;
   larger_content_geo.OffsetSize(excess_border, excess_border);
 
@@ -767,8 +772,13 @@
   nux::Geometry geo = geometry;
   bgs = 0;
 
+<<<<<<< TREE
   int excess_border = (Settings::Instance().GetFormFactor() != FormFactor::NETBOOK) ? EXCESS_BORDER : 0;
 
+=======
+  int excess_border = (dash::Settings::Instance().GetFormFactor() != dash::FormFactor::NETBOOK) ? EXCESS_BORDER : 0;
+
+>>>>>>> MERGE-SOURCE
   nux::Geometry larger_content_geo = content_geo;
   larger_content_geo.OffsetSize(excess_border, excess_border);
 

=== modified file 'unity-shared/SearchBar.cpp'
=== modified file 'unity-shared/UnityWindowView.h'
--- unity-shared/UnityWindowView.h	2012-05-17 11:52:32 +0000
+++ unity-shared/UnityWindowView.h	2012-05-24 17:16:22 +0000
@@ -20,8 +20,13 @@
 #ifndef UNITYWINDOWVIEW_H
 #define UNITYWINDOWVIEW_H
 
+<<<<<<< TREE
 #include "unity-shared/BackgroundEffectHelper.h"
 #include "Introspectable.h"
+=======
+#include "BackgroundEffectHelper.h"
+#include "Introspectable.h"
+>>>>>>> MERGE-SOURCE
 #include "UnityWindowStyle.h"
 #include <sigc++/sigc++.h>
 

=== modified file 'unity-shared/WindowManager.h'
--- unity-shared/WindowManager.h	2012-05-07 00:49:31 +0000
+++ unity-shared/WindowManager.h	2012-05-24 17:16:22 +0000
@@ -23,9 +23,15 @@
 #include <gdk/gdkx.h>
 #include <core/core.h>
 
+<<<<<<< TREE
 #include "unity-shared/Introspectable.h"
 
 class WindowManager : public unity::debug::Introspectable
+=======
+#include "Introspectable.h"
+
+class WindowManager : public unity::debug::Introspectable
+>>>>>>> MERGE-SOURCE
 {
   // This is a glue interface that breaks the dependancy of Unity with Compiz
   // Basically it has a default implementation that does nothing useful, but