Merge lp:~unity-team/unity/libunity-7.0-breakage-tests into lp:~unity-team/unity/libunity-7.0-breakage

[Nick Dedekind]

Added/Updated unit tests for new libunity scope API.

Added/Updated unit tests for new libunity scope API.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3083
http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-ci/17/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-raring-amd64-ci/17/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-team-unity-libunity-7.0-breakage-ci/17/rebuild

review: Needs Fixing (continuous-integration)

[Łukasz Zemczak (sil2100)]

+1 regarding the autopilot parts

review: Approve (autopilot)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3088
http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-ci/18/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-raring-amd64-ci/18/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-team-unity-libunity-7.0-breakage-ci/18/rebuild

review: Needs Fixing (continuous-integration)

[Nick Dedekind (nick-dedekind)]

- TEST(TestDesktopUtilitiesDataDirectories, TestGetUserDataDirectory)
- TEST(TestDesktopUtilitiesDataDirectories, TestGetSystemDataDirectory)
- TEST(TestDesktopUtilitiesDataDirectories, TestGetDataDirectory)

Removed these tests. Calling the functions these tests are testing before running these tests invalidates the results (:S). glib caches the function results and therefore does not change their values when XDG folders update.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3089
http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-ci/19/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-raring-amd64-ci/19

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-team-unity-libunity-7.0-breakage-ci/19/rebuild

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-03-20 13:14:31 +0000
+++ CMakeLists.txt	2013-03-21 14:03:22 +0000
@@ -53,6 +53,8 @@
 
 if (CMAKE_BUILD_TYPE MATCHES coverage)
   set (COVERAGE_XML_FILE "${CMAKE_BINARY_DIR}/coverage.xml")
+  set (COVERAGE_INFO_FILE "${CMAKE_BINARY_DIR}/coverage-html.info")
+  set (COVERAGE_HTML_DIR "${CMAKE_BINARY_DIR}/coverage-html")
 
   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage" )
   set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage" )
@@ -67,6 +69,20 @@
       add_custom_target (coverage-xml 
           COMMAND  "${GCOVR_EXECUTABLE}" --exclude="tests.*" --exclude="obj-.*" -x -r "${CMAKE_SOURCE_DIR}" -o "${COVERAGE_XML_FILE}")
   endif()
+
+  find_program(LCOV_EXECUTABLE lcov HINTS ${LCOV_ROOT} "${LCOV_ROOT}/bin")
+  find_program(GENHTML_EXECUTABLE genhtml HINTS ${GENHTML_ROOT} "${GENHTML_ROOT}/bin")
+  if (NOT LCOV_EXECUTABLE)
+      message(FATAL_ERROR "Cannot enable coverage targets because gcovr was not found.")
+  elseif (NOT GENHTML_EXECUTABLE)
+      message(FATAL_ERROR "Cannot enable coverage targets because genhtml was not found.")
+  else ()
+      message (STATUS "Enabling HTML coverage report")
+      add_custom_target (coverage-html 
+          COMMAND "${LCOV_EXECUTABLE}" --directory "${CMAKE_BINARY_DIR}" --capture --output-file "${COVERAGE_INFO_FILE}"
+          COMMAND "${GENHTML_EXECUTABLE}" --output-directory "${COVERAGE_HTML_DIR}" "${COVERAGE_INFO_FILE}")
+  endif()
+
 endif (CMAKE_BUILD_TYPE MATCHES coverage)
 
 

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2013-03-20 13:14:31 +0000
+++ tests/CMakeLists.txt	2013-03-21 14:03:22 +0000
@@ -16,16 +16,20 @@
 configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/applications/kde4/afile.desktop
                 ${CMAKE_BINARY_DIR}/tests/data/applications/kde4/afile.desktop)
 
-configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/lenses/social/social.lens
-                ${CMAKE_BINARY_DIR}/tests/data/lenses/social/social.lens)
-configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/lenses/files/files.lens
-                ${CMAKE_BINARY_DIR}/tests/data/lenses/files/files.lens)
-configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/lenses/applications/applications.lens
-                ${CMAKE_BINARY_DIR}/tests/data/lenses/applications/applications.lens)
-configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/lenses/invalid-lens-file/invalid-lens-file.lens
-                ${CMAKE_BINARY_DIR}/tests/data/lenses/invalid-lens-file/invalid-lens-file.lens)
-configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/lenses/invalid-lens-group/invalid-lens-group.lens
-                ${CMAKE_BINARY_DIR}/tests/data/lenses/invalid-lens-group/invalid-lens-group.lens)
+configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/unity/scopes/testscope1.scope
+                ${CMAKE_BINARY_DIR}/tests/data/unity/scopes/testscope1.scope)
+configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/unity/scopes/testscope2.scope
+                ${CMAKE_BINARY_DIR}/tests/data/unity/scopes/testscope2.scope)
+configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/unity/scopes/testscope3.scope
+                ${CMAKE_BINARY_DIR}/tests/data/unity/scopes/testscope3.scope)
+configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/unity/scopes/testscope4.scope
+                ${CMAKE_BINARY_DIR}/tests/data/unity/scopes/testscope4.scope)
+configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/unity/sounds/brownnoise.mp3
+                ${CMAKE_BINARY_DIR}/tests/data/unity/sounds/brownnoise.mp3 COPYONLY)
+configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/unity/sounds/pinknoise.mp3
+                ${CMAKE_BINARY_DIR}/tests/data/unity/sounds/pinknoise.mp3 COPYONLY)
+configure_file (${CMAKE_CURRENT_SOURCE_DIR}/data/unity/sounds/whitenoise.mp3
+                ${CMAKE_BINARY_DIR}/tests/data/unity/sounds/whitenoise.mp3 COPYONLY)
 
 #
 # Unit tests
@@ -95,8 +99,18 @@
                  test_service_hud.cpp
                  test_service_main.cpp
                  test_service_model.cpp
-                 test_service_panel.cpp)
-  target_link_libraries(test-gtest-service unity-shared ${LIBS})
+                 test_service_panel.cpp
+                 test_service_scope.cpp)
+
+  # Build plain C files separately so they don't try to include the
+  # C++ pch.
+  add_library(test-gtest-service-plainc STATIC
+              test_scope_impl.c)
+
+  target_link_libraries(test-gtest-service
+                        test-gtest-service-plainc
+                        unity-shared
+                        ${LIBS})
 
 # gtest-slow, start moving things over that are slow running tests
   set (GTEST_SLOW_SOURCES
@@ -135,6 +149,7 @@
        test_glib_source.cpp
        test_glib_variant.cpp
        test_grabhandle.cpp
+       test_gsettings_scopes.cpp
        test_desktop_utilities.cpp
        test_indicator.cpp
        test_indicator_appmenu.cpp
@@ -149,6 +164,7 @@
        test_layout_system.cpp
        test_model_iterator.cpp
        test_previews.cpp
+       test_scope_data.cpp
        test_time_util.cpp
        test_ubus.cpp
        test_unityshell_private.cpp
@@ -204,10 +220,14 @@
                  test_utils.h
                  test_ratings_filter.cpp
                  test_results.cpp
+                 test_scope.cpp
+                 test_scope_filter.cpp
+                 test_scope_proxy.cpp
+                 test_tracks.cpp
                 )
   target_link_libraries(test-gtest-dbus gtest unity-shared ${LIBS})
   add_test(UnityGTestDBus test-gtest-dbus)
-  add_dependencies(test-gtest-dbus unity-core-${UNITY_API_VERSION} test-gtest-service gtest)
+  add_dependencies(test-gtest-dbus unity-core-${UNITY_API_VERSION} unity-shared test-gtest-service gtest)
 
 if (ENABLE_X_SUPPORT)
 # Tests that require X
@@ -219,6 +239,8 @@
                  test_application_launcher_icon.cpp
                  test_bamf_application.cpp
                  test_bfb_launcher_icon.cpp
+                 test_dashview.cpp
+                 test_dashview_impl.cpp
                  test_dash_controller.cpp
                  test_desktop_launcher_icon.cpp
                  test_device_launcher_section.cpp
@@ -233,6 +255,7 @@
                  test_hud_view.cpp
                  test_icon_loader.cpp
                  test_im_text_entry.cpp
+                 test_keyboard_util.cpp
                  test_im_text_entry_class.cpp
                  test_launcher.cpp
                  test_launcher_controller.cpp
@@ -242,13 +265,13 @@
                  test_launcher_icon.cpp
                  test_launcher_minimize_speed.cpp
                  test_launcher_tooltip.cpp
-                 test_keyboard_util.cpp
                  test_panel_indicators_view.cpp
                  test_panel_menu_view.cpp
                  test_panel_style.cpp
                  test_panel_tray.cpp
                  test_panel_view.cpp
                  test_places_group.cpp
+                 test_preview_player.cpp
                  test_previews_application.cpp
                  test_previews_generic.cpp
                  test_previews_movie.cpp
@@ -260,6 +283,8 @@
                  test_quicklist_view.cpp
                  test_result_renderer.cpp
                  test_resultviewgrid.cpp
+                 test_scope_bar.cpp
+                 test_scopeview.cpp
                  test_searchbar.cpp
                  test_session_button.cpp
                  test_session_controller.cpp

=== added file 'tests/MockCategories.h'
--- tests/MockCategories.h	1970-01-01 00:00:00 +0000
+++ tests/MockCategories.h	2013-03-21 14:03:22 +0000
@@ -0,0 +1,67 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#ifndef _UNITY_MOCK_CATEGORIES_H
+#define _UNITY_MOCK_CATEGORIES_H
+
+#include <dee.h>
+
+namespace unity
+{
+namespace dash
+{
+
+class MockCategories : public Categories
+{
+public:
+MockCategories(unsigned count)
+: Categories(LOCAL)
+, model_(dee_sequence_model_new())
+{
+  dee_model_set_schema(model_, "s", "s", "s", "s", "a{sv}", nullptr);
+  AddResults(count);
+
+  SetModel(model_);
+}
+
+void AddResults(unsigned count)
+{
+  GVariantBuilder b;
+  g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
+  GVariant *hints = g_variant_builder_end(&b);
+
+  for(unsigned i = 0; i < count; ++i)
+  {
+    dee_model_append(model_,
+                     ("cat"+std::to_string(i)).c_str(),
+                     ("Category "+std::to_string(i)).c_str(),
+                     "gtk-apply",
+                     "grid",
+                     hints);
+  }
+  g_variant_unref(hints);
+}
+
+glib::Object<DeeModel> model_;
+};
+
+}
+}
+
+#endif // _UNITY_MOCK_CATEGORIES_H
\ No newline at end of file

=== modified file 'tests/autopilot/unity/emulators/dash.py'
--- tests/autopilot/unity/emulators/dash.py	2013-02-21 10:03:21 +0000
+++ tests/autopilot/unity/emulators/dash.py	2013-03-21 14:03:22 +0000
@@ -9,7 +9,8 @@
 
 from __future__ import absolute_import
 
-from autopilot.emulators.X11 import Keyboard, Mouse
+
+from autopilot.emulators.input import get_keyboard, get_mouse
 from autopilot.keybindings import KeybindingsHelper
 from testtools.matchers import GreaterThan
 
@@ -23,6 +24,11 @@
 class DashController(UnityIntrospectionObject, KeybindingsHelper):
     """The main dash controller object."""
 
+    def __init__(self, *args, **kwargs):
+        super(DashController, self).__init__(*args, **kwargs)
+        self.keyboard = get_keyboard()
+        self.mouse = get_mouse()
+
     def get_dash_view(self):
         """Get the dash view that's attached to this controller."""
         return self.get_children_by_type(DashView)[0]
@@ -89,41 +95,41 @@
         Assumes dash is already visible, and search bar has keyboard focus.
 
         """
-        self._keyboard.press_and_release("Ctrl+a")
-        self._keyboard.press_and_release("Delete")
+        self.keyboard.press_and_release("Ctrl+a")
+        self.keyboard.press_and_release("Delete")
         self.search_string.wait_for("")
 
-    def reveal_application_lens(self, clear_search=True):
-        """Reveal the application lense."""
-        logger.debug("Revealing application lens with Super+a.")
-        self._reveal_lens("lens_reveal/apps", clear_search)
-        return self.view.get_lensview_by_name("applications.lens")
-
-    def reveal_music_lens(self, clear_search=True):
-        """Reveal the music lense."""
-        logger.debug("Revealing music lens with Super+m.")
-        self._reveal_lens("lens_reveal/music", clear_search)
-        return self.view.get_lensview_by_name("music.lens")
-
-    def reveal_file_lens(self, clear_search=True):
-        """Reveal the file lense."""
-        logger.debug("Revealing file lens with Super+f.")
-        self._reveal_lens("lens_reveal/files", clear_search)
-        return self.view.get_lensview_by_name("files.lens")
-
-    def reveal_video_lens(self, clear_search=True):
-        """Reveal the video lens"""
-        logger.debug("Revealing video lens with Super+v.")
-        self._reveal_lens("lens_reveal/video", clear_search)
-        return self.view.get_lensview_by_name("video.lens")
-
-    def reveal_command_lens(self, clear_search=True):
-        """Reveal the 'run command' lens."""
-        logger.debug("Revealing command lens with Alt+F2.")
-        self._reveal_lens("lens_reveal/command", clear_search)
-        return self.view.get_lensview_by_name("commands.lens")
-
-    def _reveal_lens(self, binding_name, clear_search):
+    def reveal_application_scope(self, clear_search=True):
+        """Reveal the application scope."""
+        logger.debug("Revealing application scope with Super+a.")
+        self._reveal_scope("lens_reveal/apps", clear_search)
+        return self.view.get_scopeview_by_name("applications.scope")
+
+    def reveal_music_scope(self, clear_search=True):
+        """Reveal the music scope."""
+        logger.debug("Revealing music scope with Super+m.")
+        self._reveal_scope("lens_reveal/music", clear_search)
+        return self.view.get_scopeview_by_name("music.scope")
+
+    def reveal_file_scope(self, clear_search=True):
+        """Reveal the file scope."""
+        logger.debug("Revealing file scope with Super+f.")
+        self._reveal_scope("lens_reveal/files", clear_search)
+        return self.view.get_scopeview_by_name("files.scope")
+
+    def reveal_video_scope(self, clear_search=True):
+        """Reveal the video scope"""
+        logger.debug("Revealing video scope with Super+v.")
+        self._reveal_scope("lens_reveal/video", clear_search)
+        return self.view.get_scopeview_by_name("video.scope")
+
+    def reveal_command_scope(self, clear_search=True):
+        """Reveal the 'run command' scope."""
+        logger.debug("Revealing command scope with Alt+F2.")
+        self._reveal_scope("lens_reveal/command", clear_search)
+        return self.view.get_scopeview_by_name("commands.scope")
+
+    def _reveal_scope(self, binding_name, clear_search):
         self.keybinding_hold(binding_name)
         self.keybinding_tap(binding_name)
         self.keybinding_release(binding_name)
@@ -132,13 +138,13 @@
             self.clear_search()
 
     @property
-    def active_lens(self):
-        return self.view.get_lensbar().active_lens
+    def active_scope(self):
+        return self.view.get_scopebar().active_scope
 
-    def get_current_lens(self):
-        """Get the currently-active LensView object."""
-        active_lens_name = self.view.get_lensbar().active_lens
-        return self.view.get_lensview_by_name(active_lens_name)
+    def get_current_scope(self):
+        """Get the currently-active ScopeView object."""
+        active_scope_name = self.view.get_scopebar().active_scope
+        return self.view.get_scopeview_by_name(active_scope_name)
 
     @property
     def geometry(self):
@@ -152,16 +158,16 @@
         """Get the search bar attached to this dash view."""
         return self.get_children_by_type(SearchBar)[0]
 
-    def get_lensbar(self):
-        """Get the lensbar attached to this dash view."""
-        return self.get_children_by_type(LensBar)[0]
+    def get_scopebar(self):
+        """Get the scopebar attached to this dash view."""
+        return self.get_children_by_type(ScopeBar)[0]
 
-    def get_lensview_by_name(self, lens_name):
-        """Get a LensView child object by it's name. For example, "home.lens"."""
-        lenses = self.get_children_by_type(LensView)
-        for lens in lenses:
-            if lens.name == lens_name:
-                return lens
+    def get_scopeview_by_name(self, scope_name):
+        """Get a ScopeView child object by it's name. For example, "home.scope"."""
+        scopes = self.get_children_by_type(ScopeView)
+        for scope in scopes:
+            if scope.name == scope_name:
+                return scope
 
     def get_preview_container(self):
         """Get the preview container attached to this dash view."""
@@ -175,24 +181,24 @@
     """The search bar for the dash view."""
 
 
-class LensBar(UnityIntrospectionObject):
-    """The bar of lens icons at the bottom of the dash."""
+class ScopeBar(UnityIntrospectionObject):
+    """The bar of scope icons at the bottom of the dash."""
     def get_icon_by_name(self, name):
-        """Get a LensBarIcon child object by it's name. For example, 'home.lens'."""
-        icons = self.get_children_by_type(LensBarIcon)
+        """Get a ScopeBarIcon child object by it's name. For example, 'home.scope'."""
+        icons = self.get_children_by_type(ScopeBarIcon)
         for icon in icons:
             if icon.name == name:
                 return icon
 
-class LensBarIcon(UnityIntrospectionObject):
-    """A lens icon at the bottom of the dash."""
-
-
-class LensView(UnityIntrospectionObject):
-    """A Lens View."""
+class ScopeBarIcon(UnityIntrospectionObject):
+    """A scope icon at the bottom of the dash."""
+
+
+class ScopeView(UnityIntrospectionObject):
+    """A Scope View."""
 
     def get_groups(self):
-        """Get a list of all groups within this lensview. May return an empty list."""
+        """Get a list of all groups within this scopeview. May return an empty list."""
         groups = self.get_children_by_type(PlacesGroup)
         return groups
 
@@ -217,11 +223,11 @@
         return None
 
     def get_num_visible_categories(self):
-        """Get the number of visible categories in this lens."""
+        """Get the number of visible categories in this scope."""
         return len([c for c in self.get_children_by_type(PlacesGroup) if c.is_visible])
 
     def get_filterbar(self):
-        """Get the filter bar for the current lense, or None if it doesn't have one."""
+        """Get the filter bar for the current scope, or None if it doesn't have one."""
         bars = self.get_children_by_type(FilterBar)
         if bars:
             return bars[0]
@@ -229,7 +235,7 @@
 
 
 class PlacesGroup(UnityIntrospectionObject):
-    """A category in the lense view."""
+    """A category in the scope view."""
 
     def get_results(self):
         """Get a list of all results within this category. May return an empty list."""
@@ -244,31 +250,36 @@
 class Result(UnityIntrospectionObject):
     """A single result in the dash."""
 
+    def __init__(self, *args, **kwargs):
+        super(Result, self).__init__(*args, **kwargs)
+        self.mouse = get_mouse()
+        self.keyboard = get_keyboard()
+
     def activate(self):
         tx = self.x + (self.width / 2)
         ty = self.y + (self.height / 2)
-        m = Mouse()
-        m.move(tx, ty)
-        m.click(1)
+        self.mouse.move(tx, ty)
+        self.mouse.click(1)
 
     def preview(self):
         tx = self.x + (self.width / 2)
         ty = self.y + (self.height / 2)
-        m = Mouse()
-        m.move(tx, ty)
-        m.click(3)
+        self.mouse.move(tx, ty)
+        self.mouse.click(3)
 
     def preview_key(self):
         tx = self.x + (self.width / 2)
         ty = self.y + (self.height / 2)
-        m = Mouse()
-        m.move(tx, ty)
+        self.mouse.move(tx, ty)
 
-        k = Keyboard()
-        k.press_and_release('Menu')
+        self.keyboard.press_and_release('Menu')
 
 class FilterBar(UnityIntrospectionObject):
-    """A filterbar, as shown inside a lens."""
+    """A filterbar, as shown inside a scope."""
+
+    def __init__(self, *args, **kwargs):
+        super(FilterBar, self).__init__(*args, **kwargs)
+        self.mouse = get_mouse()
 
     def get_num_filters(self):
         """Get the number of filters in this filter bar."""
@@ -285,7 +296,7 @@
 
     @property
     def expanded(self):
-        """Return True if the filterbar on this lens is expanded, False otherwise.
+        """Return True if the filterbar on this scope is expanded, False otherwise.
         """
         searchbar = self._get_searchbar()
         return searchbar.showing_filters
@@ -296,9 +307,8 @@
             searchbar = self._get_searchbar()
             tx = searchbar.filter_label_x + (searchbar.filter_label_width / 2)
             ty = searchbar.filter_label_y + (searchbar.filter_label_height / 2)
-            m = Mouse()
-            m.move(tx, ty)
-            m.click()
+            self.mouse.move(tx, ty)
+            self.mouse.click()
             self.expanded.wait_for(True)
 
     def ensure_collapsed(self):
@@ -307,9 +317,8 @@
             searchbar = self._get_searchbar()
             tx = searchbar.filter_label_x + (searchbar.filter_label_width / 2)
             ty = searchbar.filter_label_y + (searchbar.filter_label_height / 2)
-            m = Mouse()
-            m.move(tx, ty)
-            m.click()
+            self.mouse.move(tx, ty)
+            self.mouse.click()
             self.expanded.wait_for(False)
 
     def _get_searchbar(self):
@@ -327,14 +336,17 @@
 class FilterExpanderLabel(UnityIntrospectionObject):
     """A label that expands into a filter within a filter bar."""
 
+    def __init__(self, *args, **kwargs):
+        super(FilterExpanderLabel, self).__init__(*args, **kwargs)
+        self.mouse = get_mouse()
+
     def ensure_expanded(self):
         """Expand the filter expander label, if it's not already"""
         if not self.expanded:
             tx = self.x + self.width / 2
             ty = self.y + self.height / 2
-            m = Mouse()
-            m.move(tx, ty)
-            m.click()
+            self.mouse.move(tx, ty)
+            self.mouse.click()
             self.expanded.wait_for(True)
 
     def ensure_collapsed(self):
@@ -342,9 +354,8 @@
         if self.expanded:
             tx = self.x + self.width / 2
             ty = self.y + self.height / 2
-            m = Mouse()
-            m.move(tx, ty)
-            m.click()
+            self.mouse.move(tx, ty)
+            self.mouse.click()
             self.expanded.wait_for(False)
 
 
@@ -357,7 +368,7 @@
 
 
 class Preview(UnityIntrospectionObject):
-    """A preview of a dash lens result."""
+    """A preview of a dash scope result."""
 
     def get_num_actions(self):
         """Get the number of actions for the preview."""
@@ -378,9 +389,8 @@
         if action:
             tx = action.x + (searchbar.width / 2)
             ty = action.y + (searchbar.height / 2)
-            m = Mouse()
-            m.move(tx, ty)
-            m.click()
+            self.mouse.move(tx, ty)
+            self.mouse.click()
 
     @property
     def cover_art(self):
@@ -404,16 +414,16 @@
 
 
 class ApplicationPreview(Preview):
-    """A application preview of a dash lens result."""
+    """A application preview of a dash scope result."""
 
 class GenericPreview(Preview):
-    """A generic preview of a dash lens result."""
+    """A generic preview of a dash scope result."""
 
 class MusicPreview(Preview):
-    """A music preview of a dash lens result."""
+    """A music preview of a dash scope result."""
 
 class MoviePreview(Preview):
-    """A movie preview of a dash lens result."""
+    """A movie preview of a dash scope result."""
 
 class PreviewContent(UnityIntrospectionObject):
     """A preview content layout for the dash previews."""
@@ -428,6 +438,10 @@
 class PreviewContainer(UnityIntrospectionObject):
     """A container view for the main dash preview widget."""
 
+    def __init__(self, *args, **kwargs):
+        super(PreviewContainer, self).__init__(*args, **kwargs)
+        self.mouse = get_mouse()
+
     @property
     def content(self):
         return self.get_content()
@@ -463,14 +477,13 @@
 
         tx = navigator.button_x + (navigator.button_width / 2)
         ty = navigator.button_y + (navigator.button_height / 2)
-        m = Mouse()
-        m.move(tx, ty)
+        self.mouse.move(tx, ty)
 
         old_preview_initiate_count = self.preview_initiate_count
 
         for i in range(count):
             self.navigate_left_enabled.wait_for(True)
-            m.click()
+            self.mouse.click()
             self.preview_initiate_count.wait_for(GreaterThan(old_preview_initiate_count))
             old_preview_initiate_count = self.preview_initiate_count
 
@@ -480,14 +493,13 @@
 
         tx = navigator.button_x + (navigator.button_width / 2)
         ty = navigator.button_y + (navigator.button_height / 2)
-        m = Mouse()
-        m.move(tx, ty)
+        self.mouse.move(tx, ty)
 
         old_preview_initiate_count = self.preview_initiate_count
 
         for i in range(count):
             self.navigate_right_enabled.wait_for(True)
-            m.click()
+            self.mouse.click()
             self.preview_initiate_count.wait_for(GreaterThan(old_preview_initiate_count))
             old_preview_initiate_count = self.preview_initiate_count
 

=== modified file 'tests/autopilot/unity/emulators/hud.py'
--- tests/autopilot/unity/emulators/hud.py	2013-02-04 19:54:47 +0000
+++ tests/autopilot/unity/emulators/hud.py	2013-03-21 14:03:22 +0000
@@ -9,7 +9,7 @@
 
 from __future__ import absolute_import
 
-from autopilot.emulators.X11 import Keyboard
+from autopilot.emulators.input import get_keyboard
 from autopilot.keybindings import KeybindingsHelper
 from HTMLParser import HTMLParser
 import re
@@ -24,7 +24,7 @@
 
     def __init__(self, *args, **kwargs):
         super(HudController, self).__init__(*args, **kwargs)
-        self.keyboard = Keyboard()
+        self.keyboard = get_keyboard()
 
     def get_hud_view(self):
         views = self.get_children_by_type(HudView)

=== modified file 'tests/autopilot/unity/emulators/launcher.py'
--- tests/autopilot/unity/emulators/launcher.py	2013-03-18 19:58:05 +0000
+++ tests/autopilot/unity/emulators/launcher.py	2013-03-21 14:03:22 +0000
@@ -9,7 +9,8 @@
 
 from __future__ import absolute_import
 
-from autopilot.emulators.X11 import Mouse, ScreenGeometry
+from autopilot.emulators.input import get_mouse
+from autopilot.emulators.X11 import ScreenGeometry
 from autopilot.keybindings import KeybindingsHelper
 from autopilot.utilities import get_compiz_option
 import logging
@@ -67,7 +68,7 @@
         self.in_keynav_mode = False
         self.in_switcher_mode = False
 
-        self._mouse = Mouse()
+        self._mouse = get_mouse()
         self._screen = ScreenGeometry()
 
     def _perform_key_nav_binding(self, keybinding):

=== modified file 'tests/autopilot/unity/emulators/panel.py'
--- tests/autopilot/unity/emulators/panel.py	2012-12-18 11:27:43 +0000
+++ tests/autopilot/unity/emulators/panel.py	2013-03-21 14:03:22 +0000
@@ -12,7 +12,7 @@
 import logging
 from time import sleep
 
-from autopilot.emulators.X11 import Mouse
+from autopilot.emulators.input import get_mouse
 from autopilot.keybindings import KeybindingsHelper
 
 from unity.emulators import UnityIntrospectionObject
@@ -53,7 +53,7 @@
 
     def __init__(self, *args, **kwargs):
         super(UnityPanel, self).__init__(*args, **kwargs)
-        self._mouse = Mouse()
+        self._mouse = get_mouse()
 
     def __get_menu_view(self):
         """Return the menu view."""
@@ -261,7 +261,7 @@
 
     def __init__(self, *args, **kwargs):
         super(WindowButton, self).__init__(*args, **kwargs)
-        self._mouse = Mouse()
+        self._mouse = get_mouse()
 
     def mouse_move_to(self):
         target_x = self.x + self.width / 2
@@ -319,7 +319,7 @@
 
     def __init__(self, *args, **kwargs):
         super(IndicatorEntry, self).__init__(*args, **kwargs)
-        self._mouse = Mouse()
+        self._mouse = get_mouse()
 
     def mouse_move_to(self):
         target_x = self.x + self.width / 2

=== modified file 'tests/autopilot/unity/emulators/quicklist.py'
--- tests/autopilot/unity/emulators/quicklist.py	2012-08-01 23:35:56 +0000
+++ tests/autopilot/unity/emulators/quicklist.py	2013-03-21 14:03:22 +0000
@@ -11,7 +11,7 @@
 
 import logging
 
-from autopilot.emulators.X11 import Mouse
+from autopilot.emulators.input import get_mouse
 
 from unity.emulators import UnityIntrospectionObject
 
@@ -21,6 +21,10 @@
 class Quicklist(UnityIntrospectionObject):
     """Represents a quicklist."""
 
+    def __init__(self, *args, **kwargs):
+        super(Quicklist, self).__init__(*args, **kwargs)
+        self._mouse = get_mouse()
+
     @property
     def items(self):
         """Individual items in the quicklist."""
@@ -56,7 +60,7 @@
         logger.debug("Moving mouse outside the quicklist %r", self)
         target_x = self.x + self.width + 10
         target_y = self.y + self.height / 2
-        Mouse().move(target_x, target_y, animate=False)
+        self._mouse.move(target_x, target_y, animate=False)
 
     @property
     def selected_item(self):
@@ -75,7 +79,7 @@
 
     def __init__(self, *args, **kwargs):
         super(QuicklistMenuItem, self).__init__(*args, **kwargs)
-        self._mouse = Mouse()
+        self._mouse = get_mouse()
 
     @property
     def geometry(self):

=== modified file 'tests/autopilot/unity/emulators/switcher.py'
--- tests/autopilot/unity/emulators/switcher.py	2013-02-04 20:28:02 +0000
+++ tests/autopilot/unity/emulators/switcher.py	2013-03-21 14:03:22 +0000
@@ -11,7 +11,7 @@
 
 import logging
 
-from autopilot.emulators.X11 import Mouse
+from autopilot.emulators.input import get_mouse
 from autopilot.keybindings import KeybindingsHelper
 
 from unity.emulators import UnityIntrospectionObject
@@ -45,7 +45,7 @@
 
     def __init__(self, *args, **kwargs):
         super(SwitcherController, self).__init__(*args, **kwargs)
-        self._mouse = Mouse()
+        self._mouse = get_mouse()
 
     def get_switcher_view(self):
         views = self.get_children_by_type(SwitcherView)

=== modified file 'tests/autopilot/unity/tests/test_command_lens.py'
--- tests/autopilot/unity/tests/test_command_lens.py	2013-02-21 10:03:21 +0000
+++ tests/autopilot/unity/tests/test_command_lens.py	2013-03-21 14:03:22 +0000
@@ -16,47 +16,47 @@
 
 import gettext
 
-class CommandLensSearchTests(UnityTestCase):
-    """Test the command lense search bahavior."""
+class CommandScopeSearchTests(UnityTestCase):
+    """Test the command scope search bahavior."""
 
     def setUp(self):
-        super(CommandLensSearchTests, self).setUp()
-        gettext.install("unity-lens-applications")
+        super(CommandScopeSearchTests, self).setUp()
+        gettext.install("unity-scope-applications")
 
     def tearDown(self):
         self.unity.dash.ensure_hidden()
-        super(CommandLensSearchTests, self).tearDown()
+        super(CommandScopeSearchTests, self).tearDown()
 
     def test_no_results(self):
         """An empty string should get no results."""
-        self.unity.dash.reveal_command_lens()
-        command_lens = self.unity.dash.get_current_lens()
+        self.unity.dash.reveal_command_scope()
+        command_scope = self.unity.dash.get_current_scope()
 
         if self.unity.dash.search_string != "":
             self.keyboard.press_and_release("Delete")
 
         self.assertThat(self.unity.dash.search_string, Eventually(Equals("")))
-        results_category = command_lens.get_category_by_name(_("Results"))
+        results_category = command_scope.get_category_by_name(_("Results"))
         self.assertThat(results_category.is_visible, Eventually(Equals(False)))
 
     def test_results_category_appears(self):
         """Results category must appear when there are some results."""
-        self.unity.dash.reveal_command_lens()
-        command_lens = self.unity.dash.get_current_lens()
+        self.unity.dash.reveal_command_scope()
+        command_scope = self.unity.dash.get_current_scope()
         # lots of apps start with 'a'...
         self.keyboard.type("a")
         self.assertThat(self.unity.dash.search_string, Eventually(Equals("a")))
-        results_category = command_lens.get_category_by_name(_("Results"))
+        results_category = command_scope.get_category_by_name(_("Results"))
         self.assertThat(results_category.is_visible, Eventually(Equals(True)))
 
     def test_result_category_actually_contains_results(self):
         """With a search string of 'a', the results category must contain some results."""
-        self.unity.dash.reveal_command_lens()
-        command_lens = self.unity.dash.get_current_lens()
+        self.unity.dash.reveal_command_scope()
+        command_scope = self.unity.dash.get_current_scope()
         # lots of apps start with 'a'...
         self.keyboard.type("a")
         self.assertThat(self.unity.dash.search_string, Eventually(Equals("a")))
-        results_category = command_lens.get_category_by_name(_("Results"))
+        results_category = command_scope.get_category_by_name(_("Results"))
         results = results_category.get_results()
         self.assertTrue(results)
 
@@ -66,7 +66,7 @@
             self.close_all_app("Text Editor")
             sleep(1)
 
-        self.unity.dash.reveal_command_lens()
+        self.unity.dash.reveal_command_scope()
         self.keyboard.type("g")
         sleep(1)
         self.keyboard.type("edit", 0.1)
@@ -76,13 +76,13 @@
         self.assertTrue(app_found)
 
     def test_ctrl_tab_switching(self):
-        """Pressing Ctrl+Tab after launching command lens must switch to Home lens."""
-        self.unity.dash.reveal_command_lens()
-        self.keybinding("dash/lens/next")
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals("home.lens")))
+        """Pressing Ctrl+Tab after launching command scope must switch to Home scope."""
+        self.unity.dash.reveal_command_scope()
+        self.keybinding("dash/scope/next")
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals("home.scope")))
 
     def test_ctrl_shift_tab_switching(self):
-        """Pressing Ctrl+Shift+Tab after launching command lens must switch to Video lens."""
-        self.unity.dash.reveal_command_lens()
-        self.keybinding("dash/lens/prev")
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals("video.lens")))
+        """Pressing Ctrl+Shift+Tab after launching command scope must switch to Video scope."""
+        self.unity.dash.reveal_command_scope()
+        self.keybinding("dash/scope/prev")
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals("video.scope")))

=== modified file 'tests/autopilot/unity/tests/test_dash.py'
--- tests/autopilot/unity/tests/test_dash.py	2013-03-18 17:23:42 +0000
+++ tests/autopilot/unity/tests/test_dash.py	2013-03-21 14:03:22 +0000
@@ -44,36 +44,36 @@
         self.unity.dash.ensure_visible()
         self.unity.dash.ensure_hidden()
 
-    def test_application_lens_shortcut(self):
-        """Application lense must reveal when Super+a is pressed."""
-        self.unity.dash.reveal_application_lens()
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals('applications.lens')))
-
-    def test_music_lens_shortcut(self):
-        """Music lense must reveal when Super+w is pressed."""
-        self.unity.dash.reveal_music_lens()
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals('music.lens')))
-
-    def test_file_lens_shortcut(self):
-        """File lense must reveal when Super+f is pressed."""
-        self.unity.dash.reveal_file_lens()
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals('files.lens')))
-
-    def test_video_lens_shortcut(self):
-        """Video lens must reveal when super+v is pressed."""
-        self.unity.dash.reveal_video_lens()
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals('video.lens')))
-
-    def test_command_lens_shortcut(self):
-        """Run Command lens must reveat on alt+F2."""
-        self.unity.dash.reveal_command_lens()
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals('commands.lens')))
-
-    def test_can_go_from_dash_to_command_lens(self):
-        """Switch to command lens without closing the dash."""
+    def test_application_scope_shortcut(self):
+        """Application scope must reveal when Super+a is pressed."""
+        self.unity.dash.reveal_application_scope()
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals('applications.scope')))
+
+    def test_music_scope_shortcut(self):
+        """Music scope must reveal when Super+w is pressed."""
+        self.unity.dash.reveal_music_scope()
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals('music.scope')))
+
+    def test_file_scope_shortcut(self):
+        """File scope must reveal when Super+f is pressed."""
+        self.unity.dash.reveal_file_scope()
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals('files.scope')))
+
+    def test_video_scope_shortcut(self):
+        """Video scope must reveal when super+v is pressed."""
+        self.unity.dash.reveal_video_scope()
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals('video.scope')))
+
+    def test_command_scope_shortcut(self):
+        """Run Command scope must reveat on alt+F2."""
+        self.unity.dash.reveal_command_scope()
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals('commands.scope')))
+
+    def test_can_go_from_dash_to_command_scope(self):
+        """Switch to command scope without closing the dash."""
         self.unity.dash.ensure_visible()
-        self.unity.dash.reveal_command_lens()
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals('commands.lens')))
+        self.unity.dash.reveal_command_scope()
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals('commands.scope')))
 
     def test_alt_f4_close_dash(self):
         """Dash must close on alt+F4."""
@@ -156,23 +156,23 @@
         self.unity.dash.ensure_visible()
         self.assertThat(self.unity.dash.visible, Eventually(Equals(True)))
 
-    def test_command_lens_opens_when_in_spread(self):
-        """This test shows the command lens opens when in spread mode."""
-        self.start_placeholder_app()
-        self.keybinding("spread/start")
-        self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True)))
-
-        self.unity.dash.reveal_command_lens()
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals('commands.lens')))
-
-    def test_lens_opens_when_in_spread(self):
-        """This test shows that any lens opens when in spread mode."""
-        self.start_placeholder_app()
-        self.keybinding("spread/start")
-        self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True)))
-
-        self.unity.dash.reveal_application_lens()
-        self.assertThat(self.unity.dash.active_lens, Eventually(Equals('applications.lens')))
+    def test_command_scope_opens_when_in_spread(self):
+        """This test shows the command scope opens when in spread mode."""
+        self.start_placeholder_app()
+        self.keybinding("spread/start")
+        self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True)))
+
+        self.unity.dash.reveal_command_scope()
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals('commands.scope')))
+
+    def test_scope_opens_when_in_spread(self):
+        """This test shows that any scope opens when in spread mode."""
+        self.start_placeholder_app()
+        self.keybinding("spread/start")
+        self.assertThat(self.unity.window_manager.scale_active, Eventually(Equals(True)))
+
+        self.unity.dash.reveal_application_scope()
+        self.assertThat(self.unity.dash.active_scope, Eventually(Equals('applications.scope')))
 
 
 class DashSearchInputTests(DashTestCase):
@@ -199,28 +199,28 @@
 
     def test_multi_key(self):
         """Pressing 'Multi_key' must not add any characters to the search."""
-        self.unity.dash.reveal_application_lens()
+        self.unity.dash.reveal_application_scope()
         self.keyboard.press_and_release('Multi_key')
         self.keyboard.type("o")
         self.assertSearchText("")
 
     def test_multi_key_o(self):
         """Pressing the sequences 'Multi_key' + '^' + 'o' must produce 'ô'."""
-        self.unity.dash.reveal_application_lens()
+        self.unity.dash.reveal_application_scope()
         self.keyboard.press_and_release('Multi_key')
         self.keyboard.type("^o")
         self.assertSearchText(u'\xf4')
 
     def test_multi_key_copyright(self):
         """Pressing the sequences 'Multi_key' + 'c' + 'o' must produce '©'."""
-        self.unity.dash.reveal_application_lens()
+        self.unity.dash.reveal_application_scope()
         self.keyboard.press_and_release('Multi_key')
         self.keyboard.type("oc")
         self.assertSearchText(u'\xa9')
 
     def test_multi_key_delete(self):
         """Pressing 'Multi_key' must not get stuck looking for a sequence."""
-        self.unity.dash.reveal_application_lens()
+        self.unity.dash.reveal_application_scope()
         self.keyboard.type("dd")
         self.keyboard.press_and_release('Multi_key')
         self.keyboard.press_and_release('BackSpace')
@@ -231,64 +231,64 @@
 class DashKeyNavTests(DashTestCase):
     """Test the unity Dash keyboard navigation."""
 
-    def test_lensbar_gets_keyfocus(self):
-        """Test that the lensbar gets key focus after using Down keypresses."""
-        self.unity.dash.ensure_visible()
-
-        # Make sure that the lens bar can get the focus
-        for i in range(self.unity.dash.get_num_rows()):
-            self.keyboard.press_and_release("Down")
-        lensbar = self.unity.dash.view.get_lensbar()
-        self.assertThat(lensbar.focused_lens_icon, Eventually(NotEquals('')))
-
-    def test_lensbar_focus_changes(self):
-        """Lensbar focused icon should change with Left and Right keypresses."""
-        self.unity.dash.ensure_visible()
-
-        for i in range(self.unity.dash.get_num_rows()):
-            self.keyboard.press_and_release("Down")
-        lensbar = self.unity.dash.view.get_lensbar()
-
-        current_focused_icon = lensbar.focused_lens_icon
+    def test_scopebar_gets_keyfocus(self):
+        """Test that the scopebar gets key focus after using Down keypresses."""
+        self.unity.dash.ensure_visible()
+
+        # Make sure that the scope bar can get the focus
+        for i in range(self.unity.dash.get_num_rows()):
+            self.keyboard.press_and_release("Down")
+        scopebar = self.unity.dash.view.get_scopebar()
+        self.assertThat(scopebar.focused_scope_icon, Eventually(NotEquals('')))
+
+    def test_scopebar_focus_changes(self):
+        """Scopebar focused icon should change with Left and Right keypresses."""
+        self.unity.dash.ensure_visible()
+
+        for i in range(self.unity.dash.get_num_rows()):
+            self.keyboard.press_and_release("Down")
+        scopebar = self.unity.dash.view.get_scopebar()
+
+        current_focused_icon = scopebar.focused_scope_icon
 
         self.keyboard.press_and_release("Right")
-        self.assertThat(lensbar.focused_lens_icon, Eventually(NotEquals(current_focused_icon)))
+        self.assertThat(scopebar.focused_scope_icon, Eventually(NotEquals(current_focused_icon)))
 
         self.keyboard.press_and_release("Left")
-        self.assertThat(lensbar.focused_lens_icon, Eventually(Equals(current_focused_icon)))
+        self.assertThat(scopebar.focused_scope_icon, Eventually(Equals(current_focused_icon)))
 
-    def test_lensbar_enter_activation(self):
-        """Must be able to activate LensBar icons that have focus with an Enter keypress."""
+    def test_scopebar_enter_activation(self):
+        """Must be able to activate ScopeBar icons that have focus with an Enter keypress."""
         self.unity.dash.ensure_visible()
 
         for i in range(self.unity.dash.get_num_rows()):
             self.keyboard.press_and_release("Down")
         self.keyboard.press_and_release("Right")
-        lensbar = self.unity.dash.view.get_lensbar()
-        focused_icon = lensbar.focused_lens_icon
+        scopebar = self.unity.dash.view.get_scopebar()
+        focused_icon = scopebar.focused_scope_icon
         self.keyboard.press_and_release("Enter")
 
-        self.assertThat(lensbar.active_lens, Eventually(Equals(focused_icon)))
+        self.assertThat(scopebar.active_scope, Eventually(Equals(focused_icon)))
 
-        # lensbar should lose focus after activation.
-        self.assertThat(lensbar.focused_lens_icon, Eventually(Equals("")))
+        # scopebar should lose focus after activation.
+        self.assertThat(scopebar.focused_scope_icon, Eventually(Equals("")))
 
     def test_focus_returns_to_searchbar(self):
         """This test makes sure that the focus is returned to the searchbar of the newly
-        activated lens."""
+        activated scope."""
         self.unity.dash.ensure_visible()
 
         for i in range(self.unity.dash.get_num_rows()):
             self.keyboard.press_and_release("Down")
         self.keyboard.press_and_release("Right")
-        lensbar = self.unity.dash.view.get_lensbar()
-        focused_icon = lensbar.focused_lens_icon
+        scopebar = self.unity.dash.view.get_scopebar()
+        focused_icon = scopebar.focused_scope_icon
         self.keyboard.press_and_release("Enter")
 
-        self.assertThat(lensbar.active_lens, Eventually(Equals(focused_icon)))
-        self.assertThat(lensbar.focused_lens_icon, Eventually(Equals("")))
+        self.assertThat(scopebar.active_scope, Eventually(Equals(focused_icon)))
+        self.assertThat(scopebar.focused_scope_icon, Eventually(Equals("")))
 
-        # Now we make sure if the newly activated lens searchbar have the focus.
+        # Now we make sure if the newly activated scope searchbar have the focus.
         self.keyboard.type("HasFocus")
 
         self.assertThat(self.unity.dash.search_string, Eventually(Equals("HasFocus")))
@@ -304,22 +304,22 @@
         self.unity.dash.ensure_visible()
         # Make sure that a category have the focus.
         self.keyboard.press_and_release("Down")
-        lens = self.unity.dash.get_current_lens()
-        category = lens.get_focused_category()
+        scope = self.unity.dash.get_current_scope()
+        category = scope.get_focused_category()
         self.assertIsNot(category, None)
         # Make sure that the category is highlighted.
         self.assertTrue(category.header_is_highlighted)
 
-    def test_control_tab_lens_cycle(self):
-        """This test makes sure that Ctrl+Tab cycles lenses."""
+    def test_control_tab_scope_cycle(self):
+        """This test makes sure that Ctrl+Tab cycles scopes."""
         self.unity.dash.ensure_visible()
 
         self.keyboard.press('Control')
         self.keyboard.press_and_release('Tab')
         self.keyboard.release('Control')
 
-        lensbar = self.unity.dash.view.get_lensbar()
-        self.assertEqual(lensbar.active_lens, u'applications.lens')
+        scopebar = self.unity.dash.view.get_scopebar()
+        self.assertEqual(scopebar.active_scope, u'applications.scope')
 
         self.keyboard.press('Control')
         self.keyboard.press('Shift')
@@ -327,33 +327,33 @@
         self.keyboard.release('Control')
         self.keyboard.release('Shift')
 
-        self.assertThat(lensbar.active_lens, Eventually(Equals('home.lens')))
+        self.assertThat(scopebar.active_scope, Eventually(Equals('home.scope')))
 
     def test_tab_cycle_category_headers(self):
         """ Makes sure that pressing tab cycles through the category headers"""
         self.unity.dash.ensure_visible()
-        lens = self.unity.dash.get_current_lens()
+        scope = self.unity.dash.get_current_scope()
 
         # Test that tab cycles through the categories.
         # + 1 is to cycle back to first header
-        for i in range(lens.get_num_visible_categories() + 1):
+        for i in range(scope.get_num_visible_categories() + 1):
             self.keyboard.press_and_release('Tab')
-            category = lens.get_focused_category()
+            category = scope.get_focused_category()
             self.assertIsNot(category, None)
 
     def test_tab_with_filter_bar(self):
         """ This test makes sure that Tab works well with the filter bara."""
-        self.unity.dash.reveal_application_lens()
-        lens = self.unity.dash.get_current_lens()
+        self.unity.dash.reveal_application_scope()
+        scope = self.unity.dash.get_current_scope()
 
         # Tabs to last category
-        for i in range(lens.get_num_visible_categories()):
+        for i in range(scope.get_num_visible_categories()):
             self.keyboard.press_and_release('Tab')
 
         self.keyboard.press_and_release('Tab')
         self.assertThat(self.unity.dash.searchbar.expander_has_focus, Eventually(Equals(True)))
 
-        filter_bar = lens.get_filterbar()
+        filter_bar = scope.get_filterbar()
         if not self.unity.dash.searchbar.showing_filters:
             self.keyboard.press_and_release('Enter')
             self.assertThat(self.unity.dash.searchbar.showing_filters, Eventually(Equals(True)))
@@ -366,17 +366,17 @@
 
         # Ensure that tab cycles back to a category header
         self.keyboard.press_and_release('Tab')
-        category = lens.get_focused_category()
+        category = scope.get_focused_category()
         self.assertIsNot(category, None)
 
     def test_bottom_up_keynav_with_filter_bar(self):
         """This test makes sure that bottom-up key navigation works well
         in the dash filter bar.
         """
-        self.unity.dash.reveal_application_lens()
-        lens = self.unity.dash.get_current_lens()
+        self.unity.dash.reveal_application_scope()
+        scope = self.unity.dash.get_current_scope()
 
-        filter_bar = lens.get_filterbar()
+        filter_bar = scope.get_filterbar()
         # Need to ensure the filter expander has focus, so if it's already
         # expanded, we collapse it first:
         filter_bar.ensure_collapsed()
@@ -496,8 +496,8 @@
         """Expanding or collapsing the filterbar must keave keyboard focus in the
         search bar.
         """
-        self.unity.dash.reveal_application_lens()
-        filter_bar = self.unity.dash.get_current_lens().get_filterbar()
+        self.unity.dash.reveal_application_scope()
+        filter_bar = self.unity.dash.get_current_scope().get_filterbar()
         filter_bar.ensure_collapsed()
 
         self.keyboard.type("hello")
@@ -519,39 +519,39 @@
         self.assertSearchText("HasFocus")
 
 
-class DashLensResultsTests(DashTestCase):
-    """Tests results from the lens view."""
+class DashScopeResultsTests(DashTestCase):
+    """Tests results from the scope view."""
 
     def test_results_message_empty_search(self):
         """This tests a message is not shown when there is no text."""
-        self.unity.dash.reveal_application_lens()
-        lens = self.unity.dash.get_current_lens()
-        self.assertThat(lens.no_results_active, Eventually(Equals(False)))
+        self.unity.dash.reveal_application_scope()
+        scope = self.unity.dash.get_current_scope()
+        self.assertThat(scope.no_results_active, Eventually(Equals(False)))
 
     def test_results_message(self):
         """This test no mesage will be shown when results are there."""
-        self.unity.dash.reveal_application_lens()
+        self.unity.dash.reveal_application_scope()
         self.keyboard.type("Terminal")
         self.assertThat(self.unity.dash.search_string, Eventually(Equals("Terminal")))
-        lens = self.unity.dash.get_current_lens()
-        self.assertThat(lens.no_results_active, Eventually(Equals(False)))
+        scope = self.unity.dash.get_current_scope()
+        self.assertThat(scope.no_results_active, Eventually(Equals(False)))
 
     def test_no_results_message(self):
-        """This test shows a message will appear in the lens."""
-        self.unity.dash.reveal_application_lens()
+        """This test shows a message will appear in the scope."""
+        self.unity.dash.reveal_application_scope()
         self.keyboard.type("qwerlkjzvxc")
         self.assertThat(self.unity.dash.search_string, Eventually(Equals("qwerlkjzvxc")))
-        lens = self.unity.dash.get_current_lens()
-        self.assertThat(lens.no_results_active, Eventually(Equals(True)))
+        scope = self.unity.dash.get_current_scope()
+        self.assertThat(scope.no_results_active, Eventually(Equals(True)))
 
     def test_results_update_on_filter_changed(self):
         """This test makes sure the results change when filters change."""
-        gettext.install("unity-lens-applications")
-        self.unity.dash.reveal_application_lens()
-        lens = self.unity.dash.get_current_lens()
+        gettext.install("unity-scope-applications")
+        self.unity.dash.reveal_application_scope()
+        scope = self.unity.dash.get_current_scope()
         self.keyboard.type(" ")
         self.assertThat(self.unity.dash.search_string, Eventually(Equals(" ")))
-        results_category = lens.get_category_by_name(_("Installed"))
+        results_category = scope.get_category_by_name(_("Installed"))
         old_results = results_category.get_results()
 
         # FIXME: This should be a method on the dash emulator perhaps, or
@@ -559,20 +559,20 @@
         # function that is only called once!
         def activate_filter(add_cleanup = False):
             # Tabs to last category
-            for i in range(lens.get_num_visible_categories()):
+            for i in range(scope.get_num_visible_categories()):
                 self.keyboard.press_and_release('Tab')
 
             self.keyboard.press_and_release('Tab')
             self.assertThat(self.unity.dash.searchbar.expander_has_focus, Eventually(Equals(True)))
 
-            filter_bar = lens.get_filterbar()
+            filter_bar = scope.get_filterbar()
             if not self.unity.dash.searchbar.showing_filters:
                 self.keyboard.press_and_release('Enter')
                 self.assertThat(self.unity.dash.searchbar.showing_filters, Eventually(Equals(True)))
                 if add_cleanup:
                     self.addCleanup(filter_bar.ensure_collapsed)
 
-            # Tab to the "Type" filter in apps lens
+            # Tab to the "Type" filter in apps scope
             self.keyboard.press_and_release('Tab')
             new_focused_filter = filter_bar.get_focused_filter()
             self.assertIsNotNone(new_focused_filter)
@@ -586,7 +586,7 @@
         activate_filter(True)
         self.addCleanup(activate_filter)
 
-        results_category = lens.get_category_by_name(_("Installed"))
+        results_category = scope.get_category_by_name(_("Installed"))
         results = results_category.get_results()
         self.assertIsNot(results, old_results)
 
@@ -597,14 +597,14 @@
 class DashVisualTests(DashTestCase):
     """Tests that the dash visual is correct."""
 
-    def test_closing_dash_hides_current_lens(self):
-        """When exiting from the dash the current lens must set it self to not visible."""
+    def test_closing_dash_hides_current_scope(self):
+        """When exiting from the dash the current scope must set it self to not visible."""
 
         self.unity.dash.ensure_visible()
-        lens = self.unity.dash.get_current_lens()
+        scope = self.unity.dash.get_current_scope()
         self.unity.dash.ensure_hidden()
 
-        self.assertThat(lens.visible, Eventually(Equals(False)))
+        self.assertThat(scope.visible, Eventually(Equals(False)))
 
     def test_dash_position_with_non_default_launcher_width(self):
         """"There should be no empty space between launcher and dash when the launcher
@@ -625,10 +625,10 @@
         """The see more results label should be baseline aligned
         with the category name label.
         """
-        self.unity.dash.reveal_application_lens()
+        self.unity.dash.reveal_application_scope()
 
-        lens = self.unity.dash.get_current_lens()
-        groups = lens.get_groups()
+        scope = self.unity.dash.get_current_scope()
+        groups = scope.get_groups()
 
         for group in groups:
             if (group.is_visible and group.expand_label_is_visible):
@@ -637,25 +637,25 @@
                 self.assertThat(expand_label_y, Equals(name_label_y))
 
 
-class DashLensBarTests(DashTestCase):
-    """Tests that the lensbar works well."""
+class DashScopeBarTests(DashTestCase):
+    """Tests that the scopebar works well."""
 
     def setUp(self):
-        super(DashLensBarTests, self).setUp()
+        super(DashScopeBarTests, self).setUp()
         self.unity.dash.ensure_visible()
-        self.lensbar = self.unity.dash.view.get_lensbar()
+        self.scopebar = self.unity.dash.view.get_scopebar()
 
     def test_click_inside_highlight(self):
-        """Lens selection should work when clicking in
+        """Scope selection should work when clicking in
         the rectangle outside of the icon.
         """
-        app_icon = self.lensbar.get_icon_by_name(u'applications.lens')
+        app_icon = self.scopebar.get_icon_by_name(u'applications.scope')
 
         self.mouse.move(app_icon.x + (app_icon.width / 2),
                         app_icon.y + (app_icon.height / 2))
         self.mouse.click()
 
-        self.assertThat(self.lensbar.active_lens, Eventually(Equals('applications.lens')))
+        self.assertThat(self.scopebar.active_scope, Eventually(Equals('applications.scope')))
 
 
 class DashBorderTests(DashTestCase):
@@ -703,11 +703,11 @@
         """Clicking into a category highlight must expand/collapse
         the view.
         """
-        gettext.install("unity-lens-applications", unicode=True)
-        lens = self.unity.dash.reveal_application_lens()
+        gettext.install("unity-scope-applications", unicode=True)
+        scope = self.unity.dash.reveal_application_scope()
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        category = lens.get_category_by_name(_("Installed"))
+        category = scope.get_category_by_name(_("Installed"))
         is_expanded = category.is_expanded
 
         self.mouse.move(self.unity.dash.view.x + self.unity.dash.view.width / 2,
@@ -722,18 +722,18 @@
 
 class PreviewInvocationTests(DashTestCase):
     """Tests that dash previews can be opened and closed in different
-    lenses.
+    scopes.
     """
-    def test_app_lens_preview_open_close(self):
-        """Right-clicking on an application lens result must show
+    def test_app_scope_preview_open_close(self):
+        """Right-clicking on an application scope result must show
         its preview.
 
         """
-        gettext.install("unity-lens-applications", unicode=True)
-        lens = self.unity.dash.reveal_application_lens()
+        gettext.install("unity-scope-applications", unicode=True)
+        scope = self.unity.dash.reveal_application_scope()
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        category = lens.get_category_by_name(_("More suggestions"))
+        category = scope.get_category_by_name(_("More suggestions"))
         results = category.get_results()
         result = results[0]
         # result.preview handles finding xy co-ords and right mouse-click
@@ -744,24 +744,24 @@
 
         self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False)))
 
-    def test_files_lens_preview_open_close(self):
-        """Right-clicking on a files lens result must show its
+    def test_files_scope_preview_open_close(self):
+        """Right-clicking on a files scope result must show its
         preview.
         """
-        gettext.install("unity-lens-files", unicode=True)
+        gettext.install("unity-scope-files", unicode=True)
 
         # Instead of skipping the test, here we can create a dummy file to open and
-        # make sure the lens result is non-empty
+        # make sure the scope result is non-empty
         (file_handle, file_path) = mkstemp()
         self.addCleanup(remove, file_path)
         gedit_win = self.start_app_window('Text Editor', files=[file_path], locale='C')
         self.addCleanup(self.close_all_app, 'Text Editor')
         self.assertProperty(gedit_win, is_focused=True)
 
-        lens = self.unity.dash.reveal_file_lens()
+        scope = self.unity.dash.reveal_file_scope()
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        category = lens.get_category_by_name(_("Recent"))
+        category = scope.get_category_by_name(_("Recent"))
         refresh_results_fn = lambda: len(category.get_results())
         self.assertThat(refresh_results_fn, Eventually(GreaterThan(0)))
         results = category.get_results()
@@ -774,18 +774,18 @@
 
         self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False)))
 
-    def test_music_lens_preview_open_close(self):
-        """Right-clicking on a music lens result must show its
+    def test_music_scope_preview_open_close(self):
+        """Right-clicking on a music scope result must show its
         preview.
         """
-        lens = self.unity.dash.reveal_music_lens()
+        scope = self.unity.dash.reveal_music_scope()
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        category = lens.get_category_by_name("Songs")
+        category = scope.get_category_by_name("Songs")
         # Incase there was no music ever played we skip the test instead
         # of failing.
         if category is None or not category.is_visible:
-            self.skipTest("This lens is probably empty")
+            self.skipTest("This scope is probably empty")
 
         results = category.get_results()
 
@@ -798,28 +798,28 @@
 
         self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(False)))
 
-    def test_video_lens_preview_open_close(self):
-        """Right-clicking on a video lens result must show its
+    def test_video_scope_preview_open_close(self):
+        """Right-clicking on a video scope result must show its
         preview.
         """
-        gettext.install("unity-lens-video", unicode=True)
+        gettext.install("unity-scope-video", unicode=True)
 
-        def get_category(lens):
-            category = lens.get_category_by_name(_("Recently Viewed"))
+        def get_category(scope):
+            category = scope.get_category_by_name(_("Recently Viewed"))
             # If there was no video played on this system this category is expected
             # to be empty, if its empty we check if the 'Online' category have any
             # contents, if not then we skip the test.
             if category is None or not category.is_visible:
-                category = lens.get_category_by_name("Online")
+                category = scope.get_category_by_name("Online")
                 if category is None or not category.is_visible:
-                    self.skipTest("This lens is probably empty")
+                    self.skipTest("This scope is probably empty")
             return category
 
-        lens = self.unity.dash.reveal_video_lens()
+        scope = self.unity.dash.reveal_video_scope()
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        self.assertThat(lambda: get_category(lens), Eventually(NotEquals(None)))
-        category = get_category(lens)
+        self.assertThat(lambda: get_category(scope), Eventually(NotEquals(None)))
+        category = get_category(scope)
 
         results = category.get_results()
 
@@ -836,11 +836,11 @@
         """Pressing menu key on a selected dash result must show
         its preview.
         """
-        gettext.install("unity-lens-applications", unicode=True)
-        lens = self.unity.dash.reveal_application_lens()
+        gettext.install("unity-scope-applications", unicode=True)
+        scope = self.unity.dash.reveal_application_scope()
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        category = lens.get_category_by_name(_("More suggestions"))
+        category = scope.get_category_by_name(_("More suggestions"))
         results = category.get_results()
         result = results[0]
         # result.preview_key() handles finding xy co-ords and key press
@@ -853,12 +853,12 @@
 
     def setUp(self):
         super(PreviewNavigateTests, self).setUp()
-        gettext.install("unity-lens-applications", unicode=True)
+        gettext.install("unity-scope-applications", unicode=True)
 
-        lens = self.unity.dash.reveal_application_lens()
+        scope = self.unity.dash.reveal_application_scope()
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        results_category = lens.get_category_by_name(_("More suggestions"))
+        results_category = scope.get_category_by_name(_("More suggestions"))
         # wait for results (we need 4 results to perorm the multi-navigation tests)
         refresh_fn = lambda: len(results_category.get_results())
         self.assertThat(refresh_fn, Eventually(GreaterThan(4)))
@@ -984,12 +984,12 @@
 
     def setUp(self):
         super(PreviewClickCancelTests, self).setUp()
-        gettext.install("unity-lens-applications")
-        lens = self.unity.dash.reveal_application_lens()
+        gettext.install("unity-scope-applications")
+        scope = self.unity.dash.reveal_application_scope()
         self.addCleanup(self.unity.dash.ensure_hidden)
         # Only testing an application preview for this test.
         self.keyboard.type("Software Updater")
-        results_category = lens.get_category_by_name(_("Installed"))
+        results_category = scope.get_category_by_name(_("Installed"))
         results = results_category.get_results()
 
         result = results[0]

=== modified file 'tests/autopilot/unity/tests/test_home_lens.py'
--- tests/autopilot/unity/tests/test_home_lens.py	2013-02-21 10:03:21 +0000
+++ tests/autopilot/unity/tests/test_home_lens.py	2013-03-21 14:03:22 +0000
@@ -15,15 +15,15 @@
 from unity.tests import UnityTestCase
 
 
-class HomeLensSearchTests(UnityTestCase):
-    """Test the command lense search bahavior."""
+class HomeScopeSearchTests(UnityTestCase):
+    """Test the command scope search bahavior."""
 
     def setUp(self):
-        super(HomeLensSearchTests, self).setUp()
+        super(HomeScopeSearchTests, self).setUp()
 
     def tearDown(self):
         self.unity.dash.ensure_hidden()
-        super(HomeLensSearchTests, self).tearDown()
+        super(HomeScopeSearchTests, self).tearDown()
 
     def test_quick_run_app(self):
         """Hitting enter runs an application even though a search might not have fully

=== modified file 'tests/autopilot/unity/tests/test_search.py'
--- tests/autopilot/unity/tests/test_search.py	2013-03-12 13:31:41 +0000
+++ tests/autopilot/unity/tests/test_search.py	2013-03-21 14:03:22 +0000
@@ -20,8 +20,8 @@
 
 # XXX: Ugly workaround for a really annoying bug (LP: #1152517) which breaks
 #  this test suite. So, to workaround, we toggle the dash once before doing any
-#  app lens search tests
-workaround_lenses_load_done = False
+#  app scope search tests
+workaround_scopes_load_done = False
 
 class SearchTestsBase(UnityTestCase):
     """Base class for testing searching in search fields.
@@ -59,28 +59,28 @@
         self.input_and_check_result(self.input, self.result) 
 
 
-# Lens tests
+# Scope tests
 
-class ApplicationLensSearchTestBase(SearchTestsBase):
-    """Common class for all tests for searching in the application lens."""
+class ApplicationScopeSearchTestBase(SearchTestsBase):
+    """Common class for all tests for searching in the application scope."""
 
     def setUp(self):
-        super(ApplicationLensSearchTestBase, self).setUp()
+        super(ApplicationScopeSearchTestBase, self).setUp()
         # XXX: Temporary workaround for LP: #1152517
-        global workaround_lenses_load_done
-        if not workaround_lenses_load_done:
+        global workaround_scopes_load_done
+        if not workaround_scopes_load_done:
             self.unity.dash.ensure_visible()
             self.unity.dash.ensure_hidden()
-            workaround_lenses_load_done = True
+            workaround_scopes_load_done = True
 
-        self.app_lens = self.unity.dash.reveal_application_lens()
+        self.app_scope = self.unity.dash.reveal_application_scope()
         self.addCleanup(self.unity.dash.ensure_hidden)
         gettext.install("unity-lens-applications", unicode=True)
 
     def input_and_check_result(self, string, expected):
         self.keyboard.type(string)
         self.assertThat(self.unity.dash.search_string, Eventually(Equals(string)))
-        category = self.app_lens.get_category_by_name(_("Installed"))
+        category = self.app_scope.get_category_by_name(_("Installed"))
         refresh_results_fn = lambda: len(category.get_results())
         self.assertThat(refresh_results_fn, Eventually(GreaterThan(0)))
         results = category.get_results()
@@ -92,8 +92,8 @@
         self.assertTrue(found)
  
 
-class ApplicationLensSearchTests(ApplicationLensSearchTestBase):
-    """Simple search tests for the application lens."""
+class ApplicationScopeSearchTests(ApplicationScopeSearchTestBase):
+    """Simple search tests for the application scope."""
 
     scenarios = [
         ('basic', {'input': 'Window Mocker', 'result': 'Window Mocker'}),
@@ -104,15 +104,15 @@
     ]
 
     def setUp(self):
-        super(ApplicationLensSearchTests, self).setUp()
+        super(ApplicationScopeSearchTests, self).setUp()
 
-    def test_application_lens_search(self):
+    def test_application_scope_search(self):
         self.do_search_test()
 
 
-class ApplicationLensFuzzySearchTests(ApplicationLensSearchTestBase):
-    """Fuzzy, erroneous search tests for the application lens.
-    This checks if the application lens will find the searched application
+class ApplicationScopeFuzzySearchTests(ApplicationScopeSearchTestBase):
+    """Fuzzy, erroneous search tests for the application scope.
+    This checks if the application scope will find the searched application
     (windowmocker here, since we want some app that has the name 
     locale-independent) when small spelling errors are made.
     """
@@ -125,9 +125,9 @@
     ]       
 
     def setUp(self):
-        super(ApplicationLensFuzzySearchTests, self).setUp()
+        super(ApplicationScopeFuzzySearchTests, self).setUp()
 
-    def test_application_lens_fuzzy_search(self):
+    def test_application_scope_fuzzy_search(self):
         self.do_search_test()
 
 

=== modified file 'tests/autopilot/unity/tests/test_shopping_lens.py'
--- tests/autopilot/unity/tests/test_shopping_lens.py	2013-02-21 10:03:21 +0000
+++ tests/autopilot/unity/tests/test_shopping_lens.py	2013-03-21 14:03:22 +0000
@@ -17,70 +17,70 @@
 from unity.tests import UnityTestCase
 
 
-class ShoppingLensTests(UnityTestCase):
-    """Test the shopping lens bahavior."""
+class ShoppingScopeTests(UnityTestCase):
+    """Test the shopping scope bahavior."""
 
     def setUp(self):
-        super(ShoppingLensTests, self).setUp()
+        super(ShoppingScopeTests, self).setUp()
         try:
             urllib2.urlopen("http://www.google.com", timeout=2)
         except urllib2.URLError, e:
             self.skip("Skipping test, no internet connection")
-        gettext.install("unity-lens-shopping")
+        gettext.install("unity-scope-shopping")
 
     def tearDown(self):
         self.unity.dash.ensure_hidden()
-        super(ShoppingLensTests, self).tearDown()
+        super(ShoppingScopeTests, self).tearDown()
 
-    def test_no_results_in_home_lens_if_empty_search(self):
-        """Test that the home lens contains no results if the search bar is empty."""
+    def test_no_results_in_home_scope_if_empty_search(self):
+        """Test that the home scope contains no results if the search bar is empty."""
         self.unity.dash.ensure_visible()
-        lens = self.unity.dash.get_current_lens()
+        scope = self.unity.dash.get_current_scope()
 
-        results_category = lens.get_category_by_name(_("More suggestions"))
+        results_category = scope.get_category_by_name(_("More suggestions"))
         refresh_results_fn = lambda: len(results_category.get_results())
         self.assertThat(refresh_results_fn, Eventually(Equals(0)))
 
-    def test_home_lens_has_shopping_results(self):
-        """Test that the home lens contains results."""
+    def test_home_scope_has_shopping_results(self):
+        """Test that the home scope contains results."""
         self.unity.dash.ensure_visible()
-        lens = self.unity.dash.get_current_lens()
+        scope = self.unity.dash.get_current_scope()
 
         self.keyboard.type("playstation")
-        results_category = lens.get_category_by_name(_("More suggestions"))
+        results_category = scope.get_category_by_name(_("More suggestions"))
 
         refresh_results_fn = lambda: len(results_category.get_results())
         self.assertThat(refresh_results_fn, Eventually(GreaterThan(1)))
 
-    def test_application_lens_has_shopping_results(self):
-        """Test that the application lens contains results."""
-        self.unity.dash.reveal_application_lens()
-        lens = self.unity.dash.get_current_lens()
+    def test_application_scope_has_shopping_results(self):
+        """Test that the application scope contains results."""
+        self.unity.dash.reveal_application_scope()
+        scope = self.unity.dash.get_current_scope()
 
         self.keyboard.type("Text Editor")
-        results_category = lens.get_category_by_name(_("More suggestions"))
+        results_category = scope.get_category_by_name(_("More suggestions"))
 
         refresh_results_fn = lambda: len(results_category.get_results())
         self.assertThat(refresh_results_fn, Eventually(GreaterThan(1)))
 
-    def test_music_lens_has_shopping_results(self):
-        """Test that the music lens contains results."""
-        self.unity.dash.reveal_music_lens()
-        lens = self.unity.dash.get_current_lens()
+    def test_music_scope_has_shopping_results(self):
+        """Test that the music scope contains results."""
+        self.unity.dash.reveal_music_scope()
+        scope = self.unity.dash.get_current_scope()
 
         self.keyboard.type("megadeth")
-        results_category = lens.get_category_by_name(_("More suggestions"))
+        results_category = scope.get_category_by_name(_("More suggestions"))
 
         refresh_results_fn = lambda: len(results_category.get_results())
         self.assertThat(refresh_results_fn, Eventually(GreaterThan(1)))
 
-    def test_preview_works_with_shopping_lens(self):
-        """This test shows the dash preview works with shopping lens results."""
+    def test_preview_works_with_shopping_scope(self):
+        """This test shows the dash preview works with shopping scope results."""
         self.unity.dash.ensure_visible()
-        lens = self.unity.dash.get_current_lens()
+        scope = self.unity.dash.get_current_scope()
 
         self.keyboard.type("playstation")
-        results_category = lens.get_category_by_name(_("More suggestions"))
+        results_category = scope.get_category_by_name(_("More suggestions"))
 
         refresh_results_fn = lambda: len(results_category.get_results())
         self.assertThat(refresh_results_fn, Eventually(GreaterThan(1)))
@@ -90,15 +90,15 @@
 
         self.assertThat(self.unity.dash.preview_displaying, Eventually(Equals(True)))
 
-    def test_shopping_lens_preview_navigate_right(self):
-        """This test shows that shopping lens results can open previews,
+    def test_shopping_scope_preview_navigate_right(self):
+        """This test shows that shopping scope results can open previews,
         then move to the next shopping result.
         """
         self.unity.dash.ensure_visible()
-        lens = self.unity.dash.get_current_lens()
+        scope = self.unity.dash.get_current_scope()
 
         self.keyboard.type("playstation")
-        results_category = lens.get_category_by_name(_("More suggestions"))
+        results_category = scope.get_category_by_name(_("More suggestions"))
 
         refresh_results_fn = lambda: len(results_category.get_results())
         self.assertThat(refresh_results_fn, Eventually(GreaterThan(2)))

=== added directory 'tests/data/unity'
=== added directory 'tests/data/unity/scopes'
=== added file 'tests/data/unity/scopes/testscope1.scope'
--- tests/data/unity/scopes/testscope1.scope	1970-01-01 00:00:00 +0000
+++ tests/data/unity/scopes/testscope1.scope	2013-03-21 14:03:22 +0000
@@ -0,0 +1,13 @@
+[Scope]
+DBusName=com.canonical.Unity.Test.Scope
+DBusPath=/com/canonical/unity/scope/testscope1
+Icon=/usr/share/unity/6/icon-sub1.svg
+RequiredMetadata=
+OptionalMetadata=
+Keywords=misc;
+Type=varia
+QueryPattern=^@
+Name=TestScope1
+Description=Find various stuff 1
+SearchHint=Search stuff 1
+Shortcut=q

=== added file 'tests/data/unity/scopes/testscope2.scope'
--- tests/data/unity/scopes/testscope2.scope	1970-01-01 00:00:00 +0000
+++ tests/data/unity/scopes/testscope2.scope	2013-03-21 14:03:22 +0000
@@ -0,0 +1,13 @@
+[Scope]
+DBusName=com.canonical.Unity.Test.Scope
+DBusPath=/com/canonical/unity/scope/testscope2
+Icon=/usr/share/unity/6/icon-sub2.svg
+RequiredMetadata=
+OptionalMetadata=
+Keywords=misc;
+Type=varia
+QueryPattern=^@
+Name=TestScope2
+Description=Find various stuff 2
+SearchHint=Search stuff 2
+Shortcut=w

=== added file 'tests/data/unity/scopes/testscope3.scope'
--- tests/data/unity/scopes/testscope3.scope	1970-01-01 00:00:00 +0000
+++ tests/data/unity/scopes/testscope3.scope	2013-03-21 14:03:22 +0000
@@ -0,0 +1,13 @@
+[Scope]
+DBusName=com.canonical.Unity.Test.Scope
+DBusPath=/com/canonical/unity/scope/testscope3
+Icon=/usr/share/unity/6/icon-sub3.svg
+RequiredMetadata=
+OptionalMetadata=
+Keywords=misc;
+Type=varia
+QueryPattern=^@
+Name=TestScope3
+Description=Find various stuff 3
+SearchHint=Search stuff 3
+Shortcut=e

=== added file 'tests/data/unity/scopes/testscope4.scope'
--- tests/data/unity/scopes/testscope4.scope	1970-01-01 00:00:00 +0000
+++ tests/data/unity/scopes/testscope4.scope	2013-03-21 14:03:22 +0000
@@ -0,0 +1,13 @@
+[Scope]
+DBusName=com.canonical.Unity.Test.Scope
+DBusPath=/com/canonical/unity/scope/testscope4
+Icon=/usr/share/unity/6/icon-sub4.svg
+RequiredMetadata=
+OptionalMetadata=
+Keywords=misc;
+Type=varia
+QueryPattern=^@
+Name=TestScope4
+Description=Find various stuff 4
+SearchHint=Search stuff 4
+Shortcut=r

=== added directory 'tests/data/unity/sounds'
=== added file 'tests/data/unity/sounds/brownnoise.mp3'
Binary files tests/data/unity/sounds/brownnoise.mp3	1970-01-01 00:00:00 +0000 and tests/data/unity/sounds/brownnoise.mp3	2013-03-21 14:03:22 +0000 differ
=== added file 'tests/data/unity/sounds/pinknoise.mp3'
Binary files tests/data/unity/sounds/pinknoise.mp3	1970-01-01 00:00:00 +0000 and tests/data/unity/sounds/pinknoise.mp3	2013-03-21 14:03:22 +0000 differ
=== added file 'tests/data/unity/sounds/whitenoise.mp3'
Binary files tests/data/unity/sounds/whitenoise.mp3	1970-01-01 00:00:00 +0000 and tests/data/unity/sounds/whitenoise.mp3	2013-03-21 14:03:22 +0000 differ
=== modified file 'tests/test_categories.cpp'
--- tests/test_categories.cpp	2013-03-12 13:49:41 +0000
+++ tests/test_categories.cpp	2013-03-21 14:03:22 +0000
@@ -13,6 +13,7 @@
 {
 
 static const string swarm_name = "com.canonical.test.categoriesmodel";
+static const string swarm_name_changing = "com.canonical.test.categoriesmodel_changing";
 static const unsigned int n_rows = 5;
 
 static void WaitForSynchronize(Categories& model)
@@ -46,12 +47,17 @@
   {
     Category adaptor = model.RowAtIndex(i);
 
-    unity::glib::String tmp(g_strdup_printf("Category %d", i));
-    string value = tmp.Str();
-    EXPECT_EQ(adaptor.name(), value);
+    unity::glib::String tmp(g_strdup_printf("cat%d", i));
+    string id = tmp.Str();
+
+    unity::glib::String tmp2(g_strdup_printf("Category %d", i));
+    string name = tmp2.Str();
+
+    EXPECT_EQ(adaptor.id(), id);
+    EXPECT_EQ(adaptor.name(), name);
     EXPECT_EQ(adaptor.icon_hint(), "gtk-apply");
+    EXPECT_EQ(adaptor.renderer_name(), "grid");
     EXPECT_EQ(adaptor.index(), i);
-    EXPECT_EQ(adaptor.renderer_name(), "grid");
   }
 }
 
@@ -82,4 +88,80 @@
   }
 }
 
+// We're testing the model's ability to store and retrieve random pointers
+TEST(TestCategories, TestOnRowChanged)
+{
+  Categories model;
+  model.swarm_name = swarm_name_changing;
+  WaitForSynchronize(model);
+
+  bool changed = false;
+  model.category_changed.connect([&changed] (Category const&) { changed = true;});
+  Utils::WaitUntilMSec(changed,
+                       2000,
+                       []() { return g_strdup_printf("Did not detect row change from %s.", swarm_name_changing.c_str()); });
+}
+
+
+// We're testing the model's ability to store and retrieve random pointers
+TEST(TestCategories, TestOnRowAdded)
+{
+  Categories model;
+  model.swarm_name = swarm_name_changing;
+  WaitForSynchronize(model);
+
+  bool added = false;
+  model.category_added.connect([&added] (Category const&) { added = true;});
+  Utils::WaitUntilMSec(added,
+                       2000,
+                       []() { return g_strdup_printf("Did not detect row add %s.", swarm_name_changing.c_str()); });
+}
+
+// We're testing the model's ability to store and retrieve random pointers
+TEST(TestCategories, TestOnRowRemoved)
+{
+  Categories model;
+  model.swarm_name = swarm_name_changing;
+  WaitForSynchronize(model);
+
+  bool removed = false;
+  model.category_removed.connect([&removed] (Category const&) { removed = true;});
+  Utils::WaitUntilMSec(removed,
+                       2000,
+                       []() { return g_strdup_printf("Did not detect row remove %s.", swarm_name_changing.c_str()); });
+}
+
+TEST(TestCategories, TestCategoryCopy)
+{
+  Categories model;
+  model.swarm_name = swarm_name_changing;
+  WaitForSynchronize(model);
+  
+  Category category = model.RowAtIndex(0);
+  Category category_2(category);
+
+  EXPECT_EQ(category.id(), category_2.id());
+  EXPECT_EQ(category.name(), category_2.name());
+  EXPECT_EQ(category.icon_hint(), category_2.icon_hint());
+  EXPECT_EQ(category.renderer_name(), category_2.renderer_name());
+  EXPECT_EQ(category.index(), category_2.index());
+}
+
+TEST(TestCategories, TestCategoryEqual)
+{
+  Categories model;
+  model.swarm_name = swarm_name_changing;
+  WaitForSynchronize(model);
+
+  Category category = model.RowAtIndex(0);
+  Category category_2(NULL, NULL, NULL);
+  category_2 = category;
+
+  EXPECT_EQ(category.id(), category_2.id());
+  EXPECT_EQ(category.name(), category_2.name());
+  EXPECT_EQ(category.icon_hint(), category_2.icon_hint());
+  EXPECT_EQ(category.renderer_name(), category_2.renderer_name());
+  EXPECT_EQ(category.index(), category_2.index());
+}
+
 }

=== removed file 'tests/test_dash_view.cpp'
--- tests/test_dash_view.cpp	2013-03-12 21:45:58 +0000
+++ tests/test_dash_view.cpp	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2013 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Andrea Azzarone <[e-mail]>
- */
-
-#include <gmock/gmock.h>
-
-#include <UnityCore/Lenses.h>
-
-#include "ApplicationStarter.h"
-#include "DashView.h"
-#include "unity-shared/DashStyle.h"
-#include "unity-shared/PanelStyle.h"
-#include "unity-shared/UnitySettings.h"
-
-#include "mock-lenses.h"
-
-using namespace unity::dash;
-using namespace testing;
-
-namespace  {
-
-struct MockApplicationStarter : public unity::ApplicationStarter {
-  typedef std::shared_ptr<MockApplicationStarter> Ptr;
-  MOCK_METHOD2(Launch, bool(std::string const&, Time));
-};
-
-
-struct TestDashView : public testing::Test {
-  TestDashView()
-    : lenses_(std::make_shared<testmocks::ThreeMockTestLenses>())
-    , application_starter_(std::make_shared<MockApplicationStarter>())
-    , dash_view_(new DashView(lenses_, application_starter_))
-  {}
-
-  unity::Settings unity_settings_;
-  Style dash_style;
-  unity::panel::Style panel_style;
-  Lenses::Ptr lenses_;
-  MockApplicationStarter::Ptr application_starter_;
-  nux::ObjectPtr<DashView> dash_view_;
-};
-
-
-TEST_F(TestDashView, LensActivatedSignal)
-{
-  EXPECT_CALL(*application_starter_, Launch("uri", _)).Times(1);
-  lenses_->GetLensAtIndex(0)->activated.emit("0xaabbcc:application://uri", NOT_HANDLED, Lens::Hints());
-
-  EXPECT_CALL(*application_starter_, Launch("uri", _)).Times(1);
-  lenses_->GetLensAtIndex(0)->activated.emit("0xaabbcc:unity-runner://uri", NOT_HANDLED, Lens::Hints());
-}
-
-}

=== added file 'tests/test_dashview.cpp'
--- tests/test_dashview.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_dashview.cpp	2013-03-21 14:03:22 +0000
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2013 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: Nick Dedekind <[e-mail]>
+ *
+ */
+
+#include <list>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <Nux/Nux.h>
+#include <NuxCore/ObjectPtr.h>
+
+#include "dash/DashView.h"
+#include "dash/ApplicationStarter.h"
+#include "unity-shared/DashStyle.h"
+#include "unity-shared/PanelStyle.h"
+#include "unity-shared/UnitySettings.h"
+
+#include "test_mock_scope.h"
+#include "test_utils.h"
+
+using namespace unity;
+using namespace unity::dash;
+using namespace testing;
+
+namespace unity
+{
+namespace dash
+{
+
+namespace
+{
+const char* scopes_default[] =  { "testscope1.scope",
+                                  "testscope2.scope",
+                                  "testscope3.scope",
+                                  "testscope4.scope",
+                                  NULL };
+
+}
+
+struct MockApplicationStarter : public unity::ApplicationStarter {
+  typedef std::shared_ptr<MockApplicationStarter> Ptr;
+  MOCK_METHOD2(Launch, bool(std::string const&, Time));
+};
+
+class TestDashView : public ::testing::Test
+{
+public:
+  TestDashView()
+  : application_starter_(std::make_shared<MockApplicationStarter>())
+  {}
+
+  virtual void SetUp() { Utils::init_gsettings_test_environment(); }
+  virtual void TearDown() { Utils::reset_gsettings_test_environment(); }
+
+  class MockDashView  : public DashView
+  {
+  public:
+    MockDashView(Scopes::Ptr const& scopes, ApplicationStarter::Ptr const& application_starter)
+    : DashView(scopes, application_starter)
+    {
+    }
+
+    using DashView::scope_views_;
+  };
+
+protected:
+  Settings unity_settings_;
+  dash::Style dash_style_;
+  panel::Style panel_style_;
+  MockApplicationStarter::Ptr application_starter_;
+};
+
+TEST_F(TestDashView, TestConstruct)
+{
+  Scopes::Ptr scopes(new MockGSettingsScopes(scopes_default));
+  nux::ObjectPtr<MockDashView> view(new MockDashView(scopes, application_starter_));
+
+  EXPECT_EQ(view->scope_views_.size(), 4) << "Error: Incorrect number of scope views (" << view->scope_views_.size() << " != 4)";
+}
+
+
+TEST_F(TestDashView, LensActivatedSignal)
+{
+  Scopes::Ptr scopes(new MockGSettingsScopes(scopes_default));
+  nux::ObjectPtr<MockDashView> view(new MockDashView(scopes, application_starter_));
+
+  LocalResult result;
+  result.uri = "application://uri";
+
+  EXPECT_CALL(*application_starter_, Launch("uri", _)).Times(1);
+  scopes->GetScopeAtIndex(0)->activated.emit(result, NOT_HANDLED, glib::HintsMap());
+
+  EXPECT_CALL(*application_starter_, Launch("uri", _)).Times(1);
+  scopes->GetScopeAtIndex(0)->activated.emit(result, NOT_HANDLED, glib::HintsMap());
+}
+
+}
+}

=== modified file 'tests/test_dashview_impl.cpp'
--- tests/test_dashview_impl.cpp	2013-02-21 10:03:21 +0000
+++ tests/test_dashview_impl.cpp	2013-03-21 14:03:22 +0000
@@ -27,52 +27,52 @@
 namespace
 {
 
-TEST(TestParseLensFilter, TestSimpleString)
+TEST(TestParseScopeFilter, TestSimpleString)
 {
-  LensFilter filter = parse_lens_uri("simple");
+  ScopeFilter filter = parse_scope_uri("simple");
 
   EXPECT_THAT(filter.id, Eq("simple"));
   EXPECT_TRUE(filter.filters.empty());
 }
 
-TEST(TestParseLensFilter, TestNonFilterParameter)
+TEST(TestParseScopeFilter, TestNonFilterParameter)
 {
   // Only params that start with "filter_" are added.
-  LensFilter filter = parse_lens_uri("uri?param=test");
+  ScopeFilter filter = parse_scope_uri("uri?param=test");
 
   EXPECT_THAT(filter.id, Eq("uri"));
   EXPECT_TRUE(filter.filters.empty());
 }
 
-TEST(TestParseLensFilter, TestSingleParameter)
+TEST(TestParseScopeFilter, TestSingleParameter)
 {
-  LensFilter filter = parse_lens_uri("uri?filter_param=test");
+  ScopeFilter filter = parse_scope_uri("uri?filter_param=test");
 
   EXPECT_THAT(filter.id, Eq("uri"));
   EXPECT_THAT(filter.filters.size(), Eq(1));
   EXPECT_THAT(filter.filters["param"], Eq("test"));
 }
 
-TEST(TestParseLensFilter, TestNoEquals)
+TEST(TestParseScopeFilter, TestNoEquals)
 {
-  LensFilter filter = parse_lens_uri("uri?filter_param");
+  ScopeFilter filter = parse_scope_uri("uri?filter_param");
 
   EXPECT_THAT(filter.id, Eq("uri"));
   EXPECT_TRUE(filter.filters.empty());
 }
 
-TEST(TestParseLensFilter, TestEmbeddedEquals)
+TEST(TestParseScopeFilter, TestEmbeddedEquals)
 {
-  LensFilter filter = parse_lens_uri("uri?filter_param=a=b");
+  ScopeFilter filter = parse_scope_uri("uri?filter_param=a=b");
 
   EXPECT_THAT(filter.id, Eq("uri"));
   EXPECT_THAT(filter.filters.size(), Eq(1));
   EXPECT_THAT(filter.filters["param"], Eq("a=b"));
 }
 
-TEST(TestParseLensFilter, TestMultipleParameters)
+TEST(TestParseScopeFilter, TestMultipleParameters)
 {
-  LensFilter filter = parse_lens_uri("uri?filter_param1=first&filter_param2=second");
+  ScopeFilter filter = parse_scope_uri("uri?filter_param1=first&filter_param2=second");
 
   EXPECT_THAT(filter.id, Eq("uri"));
   EXPECT_THAT(filter.filters.size(), Eq(2));

=== modified file 'tests/test_dbus_indicators.cpp'
--- tests/test_dbus_indicators.cpp	2013-02-21 10:03:21 +0000
+++ tests/test_dbus_indicators.cpp	2013-03-21 14:03:22 +0000
@@ -39,7 +39,7 @@
     dbus_indicators.reset(new DBusIndicatorsTest ());
 
     // wait until the dbus indicator has connected to the panel service
-    Utils::WaitUntil(sigc::mem_fun(*dbus_indicators, &DBusIndicatorsTest::IsConnected));
+    Utils::WaitUntil(sigc::mem_fun(*dbus_indicators, &DBusIndicatorsTest::IsConnected), true, 5);
   }
 
   bool TriggerResync1Sent() const
@@ -75,7 +75,7 @@
 TEST_F(TestDBusIndicators, TestSync)
 {
   // wait until the dbus indicator gets any indicator from the panel service
-  Utils::WaitUntil(sigc::mem_fun(*dbus_indicators, &DBusIndicatorsTest::HasIndicators));
+  Utils::WaitUntil(sigc::mem_fun(*dbus_indicators, &DBusIndicatorsTest::HasIndicators), true, 5);
 
   EXPECT_EQ(dbus_indicators->GetIndicators().size(), 1);
   EXPECT_EQ(dbus_indicators->GetIndicators().front()->GetEntries().size(), 2);
@@ -85,7 +85,7 @@
   // Tell the service to trigger a resync and to send the entries in the reverse order
   CallPanelMethod("TriggerResync1");
 
-  Utils::WaitUntil(sigc::mem_fun(this, &TestDBusIndicators::TriggerResync1Sent));
+  Utils::WaitUntil(sigc::mem_fun(this, &TestDBusIndicators::TriggerResync1Sent), true, 5);
   // We know the resync has been sent, but it may have not been processed
   // so do one interation of the main loop more
   g_main_context_iteration(g_main_context_get_thread_default(), TRUE);

=== modified file 'tests/test_desktop_utilities.cpp'
--- tests/test_desktop_utilities.cpp	2012-11-06 18:19:09 +0000
+++ tests/test_desktop_utilities.cpp	2013-03-21 14:03:22 +0000
@@ -106,61 +106,73 @@
               Eq("subdir1-subdir2-to.desktop"));
 }
 
-TEST(TestDesktopUtilitiesDataDirectories, TestGetUserDataDirectory)
-{
-  const gchar* env = g_getenv("XDG_DATA_HOME");
-  std::string old_home = env ? env : "";
-
-  g_setenv("XDG_DATA_HOME", "UnityUserConfig", TRUE);
-
-  std::string const& user_data_dir = DesktopUtilities::GetUserDataDirectory();
-
-  g_setenv("XDG_DATA_HOME", old_home.c_str(), TRUE);
-
-  EXPECT_THAT(user_data_dir, Eq("UnityUserConfig"));
-}
-
-TEST(TestDesktopUtilitiesDataDirectories, TestGetSystemDataDirectory)
-{
-  const gchar* env = g_getenv("XDG_DATA_DIRS");
-  std::string old_dirs = env ? env : "";
-  g_setenv("XDG_DATA_DIRS", ("dir1:dir2::dir3:dir4:"+LOCAL_DATA_DIR).c_str(), TRUE);
-
-  std::vector<std::string> const& system_dirs = DesktopUtilities::GetSystemDataDirectories();
-
-  g_setenv("XDG_DATA_DIRS", old_dirs.c_str(), TRUE);
-
-  ASSERT_THAT(system_dirs.size(), Eq(5));
-  EXPECT_THAT(system_dirs[0], Eq("dir1"));
-  EXPECT_THAT(system_dirs[1], Eq("dir2"));
-  EXPECT_THAT(system_dirs[2], Eq("dir3"));
-  EXPECT_THAT(system_dirs[3], Eq("dir4"));
-  EXPECT_THAT(system_dirs[4], Eq(LOCAL_DATA_DIR));
-}
-
-TEST(TestDesktopUtilitiesDataDirectories, TestGetDataDirectory)
-{
-  const gchar* env = g_getenv("XDG_DATA_DIRS");
-  std::string old_dirs = env ? env : "";
-  env = g_getenv("XDG_DATA_HOME");
-  std::string old_home = env ? env : "";
-
-  g_setenv("XDG_DATA_DIRS", ("dir1:dir2::dir3:dir4:"+LOCAL_DATA_DIR).c_str(), TRUE);
-  g_setenv("XDG_DATA_HOME", "UnityUserConfig", TRUE);
-
-  std::vector<std::string> const& data_dirs = DesktopUtilities::GetDataDirectories();
-
-  g_setenv("XDG_DATA_DIRS", old_dirs.c_str(), TRUE);
-  g_setenv("XDG_DATA_HOME", old_home.c_str(), TRUE);
-
-  ASSERT_THAT(data_dirs.size(), Eq(6));
-  EXPECT_THAT(data_dirs[0], Eq("dir1"));
-  EXPECT_THAT(data_dirs[1], Eq("dir2"));
-  EXPECT_THAT(data_dirs[2], Eq("dir3"));
-  EXPECT_THAT(data_dirs[3], Eq("dir4"));
-  EXPECT_THAT(data_dirs[4], Eq(LOCAL_DATA_DIR));
-  EXPECT_THAT(data_dirs[5], Eq("UnityUserConfig"));
-}
+// We can't test this. GetUserDataDirectory uses g_get_user_data_dir which caches data dir.
+// If we perform a DesktopUtilities::GetUserDataDirectory(); before running this test, the test will fail, because setting the XDG_DATA_HOME
+// will not change the cached value.
+
+// TEST(TestDesktopUtilitiesDataDirectories, TestGetUserDataDirectory)
+// {
+//   const gchar* env = g_getenv("XDG_DATA_HOME");
+//   std::string old_home = env ? env : "";
+
+//   g_setenv("XDG_DATA_HOME", "UnityUserConfig", TRUE);
+
+//   std::string const& user_data_dir = DesktopUtilities::GetUserDataDirectory();
+
+//   g_setenv("XDG_DATA_HOME", old_home.c_str(), TRUE);
+
+//   EXPECT_THAT(user_data_dir, Eq("UnityUserConfig"));
+// }
+
+// We can't test this. GetSystemDataDirectories uses g_get_system_data_dirs which caches the values.
+// If we perform a DesktopUtilities::GetSystemDataDirectories(); before running this test, the test will fail, because setting the XDG_DATA_DIRS
+// will not change the cached value.
+
+// TEST(TestDesktopUtilitiesDataDirectories, TestGetSystemDataDirectory)
+// {
+//   const gchar* env = g_getenv("XDG_DATA_DIRS");
+//   std::string old_dirs = env ? env : "";
+//   g_setenv("XDG_DATA_DIRS", ("dir1:dir2::dir3:dir4:"+LOCAL_DATA_DIR).c_str(), TRUE);
+
+//   std::vector<std::string> const& system_dirs = DesktopUtilities::GetSystemDataDirectories();
+
+//   g_setenv("XDG_DATA_DIRS", old_dirs.c_str(), TRUE);
+
+//   ASSERT_THAT(system_dirs.size(), Eq(5));
+//   EXPECT_THAT(system_dirs[0], Eq("dir1"));
+//   EXPECT_THAT(system_dirs[1], Eq("dir2"));
+//   EXPECT_THAT(system_dirs[2], Eq("dir3"));
+//   EXPECT_THAT(system_dirs[3], Eq("dir4"));
+//   EXPECT_THAT(system_dirs[4], Eq(LOCAL_DATA_DIR));
+// }
+
+// We can't test this. TestGetDataDirectory uses g_get_system_data_dirs which caches the values.
+// If we perform a DesktopUtilities::TestGetDataDirectory(); before running this test, the test will fail, because setting the XDG_DATA_DIRS or XDG_DATA_HOME
+// will not change the cached value.
+
+// TEST(TestDesktopUtilitiesDataDirectories, TestGetDataDirectory)
+// {
+//   const gchar* env = g_getenv("XDG_DATA_DIRS");
+//   std::string old_dirs = env ? env : "";
+//   env = g_getenv("XDG_DATA_HOME");
+//   std::string old_home = env ? env : "";
+
+//   g_setenv("XDG_DATA_DIRS", ("dir1:dir2::dir3:dir4:"+LOCAL_DATA_DIR).c_str(), TRUE);
+//   g_setenv("XDG_DATA_HOME", "UnityUserConfig", TRUE);
+
+//   std::vector<std::string> const& data_dirs = DesktopUtilities::GetDataDirectories();
+
+//   g_setenv("XDG_DATA_DIRS", old_dirs.c_str(), TRUE);
+//   g_setenv("XDG_DATA_HOME", old_home.c_str(), TRUE);
+
+//   ASSERT_THAT(data_dirs.size(), Eq(6));
+//   EXPECT_THAT(data_dirs[0], Eq("dir1"));
+//   EXPECT_THAT(data_dirs[1], Eq("dir2"));
+//   EXPECT_THAT(data_dirs[2], Eq("dir3"));
+//   EXPECT_THAT(data_dirs[3], Eq("dir4"));
+//   EXPECT_THAT(data_dirs[4], Eq(LOCAL_DATA_DIR));
+//   EXPECT_THAT(data_dirs[5], Eq("UnityUserConfig"));
+// }
 
 TEST(TestDesktopUtilities, TestGetDesktopPathById)
 {

=== modified file 'tests/test_glib_source.cpp'
--- tests/test_glib_source.cpp	2013-02-21 10:03:21 +0000
+++ tests/test_glib_source.cpp	2013-03-21 14:03:22 +0000
@@ -437,7 +437,7 @@
   idle.Run(&OnSourceCallbackStop);
   EXPECT_TRUE(idle.IsRunning());
 
-  Utils::WaitUntilMSec([&idle] {return idle.IsRunning();}, false, 300);
+  Utils::WaitUntilMSec([&idle] {return idle.IsRunning();}, false, 20000);
   EXPECT_TRUE(callback_called);
   EXPECT_EQ(callback_call_count, 1);
 }

=== modified file 'tests/test_glib_variant.cpp'
--- tests/test_glib_variant.cpp	2013-03-12 13:31:41 +0000
+++ tests/test_glib_variant.cpp	2013-03-21 14:03:22 +0000
@@ -118,10 +118,16 @@
 
   g_variant_builder_init (&b, G_VARIANT_TYPE ("a{sv}"));
   variant::BuilderWrapper bw (&b);
-  bw.add ("string-key", "string-value");
-  bw.add ("int-key", 123);
+  bw.add ("charstring-key", "charstring-value");
+  bw.add ("string-key", std::string("string-value"));
+  bw.add ("gint32-key", (gint32)-1);
+  bw.add ("guint32-key", (guint32)-2);
+  bw.add ("gint64-key", (gint64)-3);
+  bw.add ("guint64-key", (guint64)-4);
+  bw.add ("float-key", (float)1.1);
+  bw.add ("double-key", (double)2.2);
   bw.add ("bool-key", true);
-  bw.add ("last", "foo");
+  bw.add ("variant-key", g_variant_new_int32(123));
 
   GVariant *dict_variant = g_variant_builder_end (&b);
   Variant dict (g_variant_new_tuple (&dict_variant, 1));
@@ -132,10 +138,15 @@
   HintsMap hints;
   EXPECT_TRUE(dict.ASVToHints (hints));
 
+  EXPECT_EQ(hints["charstring-key"].GetString(), "charstring-value");
   EXPECT_EQ(hints["string-key"].GetString(), "string-value");
-  EXPECT_EQ(hints["int-key"].GetInt32(), 123);
+  EXPECT_EQ(hints["gint32-key"].GetInt32(), (gint32)-1);
+  EXPECT_EQ(hints["guint32-key"].GetUInt32(), (guint32)-2);
+  EXPECT_EQ(hints["gint64-key"].GetInt64(), (gint64)-3);
+  EXPECT_EQ(hints["guint64-key"].GetUInt64(), (guint64)-4);
+  EXPECT_EQ(hints["float-key"].GetFloat(), (float)1.1);
+  EXPECT_EQ(hints["double-key"].GetDouble(), (double)2.2);
   EXPECT_EQ(hints["bool-key"].GetBool(), true);
-  EXPECT_EQ(hints["last"].GetString(), "foo");
 
   // throw away all references to the original variant
   dict = g_variant_new_string ("bar");
@@ -144,10 +155,15 @@
   EXPECT_EQ(dict.GetString(), "bar");
 
   // this has to still work
+  EXPECT_EQ(hints["charstring-key"].GetString(), "charstring-value");
   EXPECT_EQ(hints["string-key"].GetString(), "string-value");
-  EXPECT_EQ(hints["int-key"].GetInt32(), 123);
+  EXPECT_EQ(hints["gint32-key"].GetInt32(), (gint32)-1);
+  EXPECT_EQ(hints["guint32-key"].GetUInt32(), (guint32)-2);
+  EXPECT_EQ(hints["gint64-key"].GetInt64(), (gint64)-3);
+  EXPECT_EQ(hints["guint64-key"].GetUInt64(), (guint64)-4);
+  EXPECT_EQ(hints["float-key"].GetFloat(), (float)1.1);
+  EXPECT_EQ(hints["double-key"].GetDouble(), (double)2.2);
   EXPECT_EQ(hints["bool-key"].GetBool(), true);
-  EXPECT_EQ(hints["last"].GetString(), "foo");
 }
 
 TEST(TestGLibVariant, GetString)
@@ -205,6 +221,4 @@
 }
 
 
-
-
 } // Namespace

=== added file 'tests/test_gsettings_scopes.cpp'
--- tests/test_gsettings_scopes.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_gsettings_scopes.cpp	2013-03-21 14:03:22 +0000
@@ -0,0 +1,230 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include <gtest/gtest.h>
+#include <glib-object.h>
+#include "test_mock_scope.h"
+#include "test_utils.h"
+
+using namespace std;
+using namespace unity;
+using namespace unity::dash;
+
+namespace
+{
+
+const char* scopes_default[] =  { "testscope1.scope",
+                                  "testscope2.scope",
+                                  "testscope3.scope",
+                                  "testscope4.scope",
+                                  NULL
+                                };
+
+const char* scopes_test_update[] = { "testscope1.scope",
+                                     "testscope4.scope",
+                                     NULL
+                                   };
+
+const char* scopes_updated[] = { "testscope1.scope",
+                                 "testscope2.scope",
+                                  "testscope3.scope",
+                                  NULL
+                                };
+
+// A new one of these is created for each test
+class TestGSettingsScopes : public testing::Test
+{
+public:
+  TestGSettingsScopes():scope_added(0),scope_removed(0),scopes_reordered(0)
+  {}
+
+  virtual void SetUp() { Utils::init_gsettings_test_environment(); }
+  virtual void TearDown() { Utils::reset_gsettings_test_environment(); }
+
+  void ConnectScope(Scopes* scopes)
+  {
+    scopes->scope_added.connect([this](Scope::Ptr const& scope, int)
+    {
+      ++scope_added;
+    });
+    scopes->scope_removed.connect([this](Scope::Ptr const& scope)
+    {
+      ++scope_removed;
+    });
+    scopes->scopes_reordered.connect([this](Scopes::ScopeList const& list)
+    {
+      ++scopes_reordered;
+    });
+  }
+
+  int scope_added;
+  int scope_removed;
+  int scopes_reordered;
+};
+
+TEST_F(TestGSettingsScopes, TestAdded)
+{
+  MockGSettingsScopes scopes(scopes_default);
+  ConnectScope(&scopes);
+
+  scopes.InsertScope("testscope1.scope", 0);
+  EXPECT_EQ(scopes.count, (unsigned int)1);
+  EXPECT_EQ(scopes_reordered, (unsigned int)0);
+
+  // add another
+  scopes.InsertScope("testscope2.scope", 1);
+  EXPECT_EQ(scopes.count, (unsigned int)2);
+  EXPECT_EQ(scopes_reordered, (unsigned int)0);
+
+  int position = -1;
+  EXPECT_TRUE(scopes.GetScope("testscope1.scope", &position) && position == 0);
+  EXPECT_TRUE(scopes.GetScope("testscope2.scope", &position) && position == 1);
+}
+
+TEST_F(TestGSettingsScopes, TestReorderBefore)
+{
+  MockGSettingsScopes scopes(scopes_default);
+  ConnectScope(&scopes);
+
+  scopes.InsertScope("testscope1.scope", 0);
+  scopes.InsertScope("testscope2.scope", 1);
+  scopes.InsertScope("testscope3.scope", 2);
+  scopes.InsertScope("testscope4.scope", 3);
+  EXPECT_EQ(scopes.count, (unsigned int)4);
+  EXPECT_EQ(scopes_reordered, (unsigned int)0);
+
+  // change position
+  scopes.InsertScope("testscope3.scope", 0);
+  EXPECT_EQ(scopes_reordered, (unsigned int)1);
+
+  int position = -1;
+  EXPECT_TRUE(scopes.GetScope("testscope3.scope", &position) && position == 0);
+  EXPECT_TRUE(scopes.GetScope("testscope1.scope", &position) && position == 1);
+  EXPECT_TRUE(scopes.GetScope("testscope2.scope", &position) && position == 2);
+  EXPECT_TRUE(scopes.GetScope("testscope4.scope", &position) && position == 3);
+}
+
+TEST_F(TestGSettingsScopes, TestReorderAfter)
+{
+  MockGSettingsScopes scopes(scopes_default);
+  ConnectScope(&scopes);
+
+  scopes.InsertScope("testscope1.scope", 0);
+  scopes.InsertScope("testscope2.scope", 1);
+  scopes.InsertScope("testscope3.scope", 2);
+  scopes.InsertScope("testscope4.scope", 3);
+  EXPECT_EQ(scopes.count, (unsigned int)4);
+  EXPECT_EQ(scopes_reordered, (unsigned int)0);
+
+  // change position
+  scopes.InsertScope("testscope2.scope", 3);
+  EXPECT_EQ(scopes_reordered, (unsigned int)1);
+
+  int position = -1;
+  EXPECT_TRUE(scopes.GetScope("testscope1.scope", &position) && position == 0);
+  EXPECT_TRUE(scopes.GetScope("testscope3.scope", &position) && position == 1);
+  EXPECT_TRUE(scopes.GetScope("testscope4.scope", &position) && position == 2);
+  EXPECT_TRUE(scopes.GetScope("testscope2.scope", &position) && position == 3);
+}
+
+
+TEST_F(TestGSettingsScopes, TestAddNonExists)
+{
+  MockGSettingsScopes scopes(scopes_default);
+  ConnectScope(&scopes);
+
+  scopes.InsertScope("non-existing.scope", 0);
+  EXPECT_EQ(scope_added, (unsigned int)0);
+  EXPECT_EQ(scopes.count, (unsigned int)0);
+}
+
+TEST_F(TestGSettingsScopes, TestAddSame)
+{
+  MockGSettingsScopes scopes(scopes_default);
+  ConnectScope(&scopes);
+
+  scopes.InsertScope("testscope1.scope", 0);
+  EXPECT_EQ(scope_added, (unsigned int)1);
+  EXPECT_EQ(scopes.count, (unsigned int)1);
+
+  // shouldnt add another
+  scopes.InsertScope("testscope1.scope", 1);
+
+  EXPECT_EQ(scope_added, (unsigned int)1);
+  EXPECT_EQ(scopes.count, (unsigned int)1);
+  EXPECT_EQ(scopes_reordered, (unsigned int)0);
+}
+
+TEST_F(TestGSettingsScopes, TestAddRemove)
+{
+  MockGSettingsScopes scopes(scopes_default);
+  ConnectScope(&scopes);
+
+  scopes.InsertScope("testscope1.scope", 0);
+  EXPECT_EQ(scope_added, (unsigned int)1);
+  EXPECT_EQ(scopes.count, (unsigned int)1);
+
+  scopes.RemoveScope("testscope1.scope");
+  EXPECT_EQ(scope_removed, (unsigned int)1);
+  EXPECT_EQ(scopes.count, (unsigned int)0);
+}
+
+TEST_F(TestGSettingsScopes, TestRemoveNonExists)
+{
+  MockGSettingsScopes scopes(scopes_default);
+  ConnectScope(&scopes);
+
+  scopes.RemoveScope("non-existing.scope");
+  EXPECT_EQ(scope_removed, (unsigned int)0);
+  EXPECT_EQ(scopes.count, (unsigned int)0);
+}
+
+TEST_F(TestGSettingsScopes, TestLoad)
+{
+  MockGSettingsScopes scopes(scopes_default);
+  ConnectScope(&scopes);
+
+  scopes.LoadScopes();
+  EXPECT_EQ(scope_added, (unsigned int)4);
+
+  int position = -1;
+  EXPECT_TRUE(scopes.GetScope("testscope1.scope", &position) && position == 0);
+  EXPECT_TRUE(scopes.GetScope("testscope2.scope", &position) && position == 1);
+  EXPECT_TRUE(scopes.GetScope("testscope3.scope", &position) && position == 2);
+  EXPECT_TRUE(scopes.GetScope("testscope4.scope", &position) && position == 3);
+}
+
+TEST_F(TestGSettingsScopes, TestLoadUpdateGSettings)
+{
+  MockGSettingsScopes scopes(scopes_test_update);
+  ConnectScope(&scopes);
+  
+  scopes.LoadScopes();
+  EXPECT_EQ(scope_added, (unsigned int)2);
+  EXPECT_EQ(scopes.count, (unsigned int)2);
+
+  scopes.UpdateScopes(scopes_updated);
+  Utils::WaitUntilMSec([this] { return scope_removed > 0; }, true, 2000);
+
+  EXPECT_EQ(scope_added, (unsigned int)4);
+  EXPECT_EQ(scope_removed, (unsigned int)1);
+  EXPECT_EQ(scopes.count, (unsigned int)3);
+}
+
+
+}

=== modified file 'tests/test_hud.cpp'
--- tests/test_hud.cpp	2013-02-21 10:03:21 +0000
+++ tests/test_hud.cpp	2013-03-21 14:03:22 +0000
@@ -3,140 +3,96 @@
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/Hud.h>
 #include <sigc++/connection.h>
+#include "test_utils.h"
 
 using namespace std;
 
+namespace unity
+{
+namespace hud
+{
+
+
 namespace
 {
 
-GMainLoop* loop_ = NULL;
-unity::hud::Hud *hud;
-
-class TestHud : public ::testing::Test
-{
-public:
-  TestHud()
-    : query_return_result(false)
-    , connected_result(false)
-  {
-  }
-  unity::hud::Hud::Queries queries;
-  bool query_return_result;
-  bool connected_result;
-  int number_signals_found;
-};
-
-TEST_F(TestHud, TestConstruction)
-{
-  loop_ = g_main_loop_new(NULL, FALSE);
-  hud = new unity::hud::Hud("com.canonical.Unity.Test", "/com/canonical/hud");
-  
-  // performs a check on the hud, if the hud is connected, report a sucess
-  auto timeout_check = [] (gpointer data) -> gboolean
-  {
-    TestHud* self = static_cast<TestHud*>(data);
-    if (hud->connected)
-    {
-      self->connected_result = true;
-      g_main_loop_quit(loop_);
-      return FALSE;
-    }
-    else
-    {
-      self->connected_result = false;
-      return TRUE;
-    }
-  };
-  
-
-  // if the hud is not connected when this lambda runs, fail.
-  auto timeout_bailout = [] (gpointer data) -> gboolean 
-  {
-    TestHud* self = static_cast<TestHud*>(data);
-    // reached timeout, failed testing
-    self->connected_result = false;
-    g_main_loop_quit(loop_);
-    return FALSE;
-  };
-  
-  g_timeout_add(1000, timeout_check, this);
-  g_timeout_add(10000, timeout_bailout, this);
-
-  g_main_loop_run(loop_);
-  
-  EXPECT_EQ(connected_result, true);
-}
-
-TEST_F(TestHud, TestQueryReturn)
-{
-  query_return_result = false;
+static void WaitForConnect(Hud::Ptr hud)
+{  
+  ::Utils::WaitUntil([hud]() { return hud->connected(); },
+                     true,
+                     10,
+                     []() { return g_strdup("Timed out waiting for hud connection"); });   
+}
+
+}
+
+TEST(TestHud, TestConstruction)
+{
+  Hud::Ptr hud(new Hud("com.canonical.Unity.Test", "/com/canonical/hud"));
+  WaitForConnect(hud);
+}
+
+TEST(TestHud, TestQueryReturn)
+{
+  Hud::Ptr hud(new Hud("com.canonical.Unity.Test", "/com/canonical/hud"));
+  WaitForConnect(hud);
+
+  bool query_return_result = false;
+  Hud::Queries queries;
   
   // make sure we receive the queries
-  auto query_connection = [this](unity::hud::Hud::Queries queries_) 
+  auto query_connection = [&query_return_result, &queries](Hud::Queries const& queries_) 
   { 
     query_return_result = true;
-    g_main_loop_quit(loop_);
     queries = queries_;
   };
-
-  auto timeout_bailout = [] (gpointer data) -> gboolean
-  {
-    TestHud* self = static_cast<TestHud*>(data);
-    self->query_return_result = false;
-    g_main_loop_quit(loop_);
-    return FALSE;
-  };
    
   sigc::connection connection = hud->queries_updated.connect(query_connection);
  
-  guint source_id = g_timeout_add(10000, timeout_bailout, this);
- 
   // next check we get 30 entries from this specific known callback
   hud->RequestQuery("Request30Queries");
-  g_main_loop_run(loop_);
-  EXPECT_EQ(query_return_result, true);
-  EXPECT_NE(queries.size(), 0);
-  g_source_remove(source_id);
+
+  ::Utils::WaitUntil([&queries, &query_return_result]() { return query_return_result && queries.size() > 0; },
+                    true,
+                    10,
+                    []() { return g_strdup("Timed out waiting for hud queries"); });
 
   // finally close the connection - Nothing to check for here
   hud->CloseQuery();
   connection.disconnect();
 }
 
-TEST_F(TestHud, TestSigEmission)
+TEST(TestHud, TestSigEmission)
 {
+  Hud::Ptr hud(new Hud("com.canonical.Unity.Test", "/com/canonical/hud"));
+  WaitForConnect(hud);
+
   // checks that the signal emission from Hud is working correctly
   // the service is setup to emit the same signal every 1000ms
   // using the same query key as its StarQuery method
   // so calling StartQuery and listening we expect > 1 
   // signal emission
-  number_signals_found = 0;
+  int number_signals_found = 0;
 
   // make sure we receive the queries
-  auto query_connection = [this](unity::hud::Hud::Queries queries_) 
+  auto query_connection = [&number_signals_found](Hud::Queries const&) 
   { 
     number_signals_found += 1;
   };
-
-  auto timeout_bailout = [] (gpointer data) -> gboolean
-  {
-    g_main_loop_quit(loop_);
-    return FALSE;
-  };
    
   sigc::connection connection = hud->queries_updated.connect(query_connection);
  
   hud->RequestQuery("Request30Queries");
-  guint source_id = g_timeout_add(10000, timeout_bailout, this);
- 
-  g_main_loop_run(loop_);
-  EXPECT_GT(number_signals_found, 1);
-  g_source_remove(source_id);
+
+  ::Utils::WaitUntil([&number_signals_found]() { return number_signals_found > 1; },
+                    true,
+                    10,
+                    []() { return g_strdup("Timed out waiting for hud signals"); });
 
   // finally close the connection - Nothing to check for here
   hud->CloseQuery();
   connection.disconnect();
-  
 }
 
 }
+}

=== modified file 'tests/test_hud_view.cpp'
--- tests/test_hud_view.cpp	2013-02-21 10:03:21 +0000
+++ tests/test_hud_view.cpp	2013-03-21 14:03:22 +0000
@@ -32,6 +32,7 @@
 #include "unity-shared/DashStyle.h"
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/UnitySettings.h"
+
 using namespace unity;
 
 namespace

=== removed file 'tests/test_lensview.cpp'
--- tests/test_lensview.cpp	2013-02-21 10:03:21 +0000
+++ tests/test_lensview.cpp	1970-01-01 00:00:00 +0000
@@ -1,98 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
- * Copyright (C) 2012 Canonical Ltd
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Nick Dedekind <[e-mail]>
- */
-
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-#include <dash/LensView.h>
-#include <dash/PlacesGroup.h>
-#include <unity-shared/DashStyle.h>
-#include <unity-shared/UnitySettings.h>
-#include <UnityCore/Category.h>
-
-using namespace unity;
-using namespace unity::dash;
-
-namespace unity
-{
-namespace dash
-{
-
-class TestLensView : public ::testing::Test
-{
-public:
-
-  class FakePlacesGroup : public PlacesGroup
-  {
-  public:
-    FakePlacesGroup():PlacesGroup(dash::Style::Instance()) {}
-
-    using PlacesGroup::_using_filters_background;
-  };
-
-  class FakeLensView : public LensView
-  {
-  public:
-    FakeLensView():LensView(Lens::Ptr(), nullptr) {}
-
-    using LensView::OnCategoryAdded;
-
-    PlacesGroup* CreatePlacesGroup()
-    {
-      FakePlacesGroup* category = new FakePlacesGroup();
-      fake_categories_.push_back(category);
-      return category;
-    }
-
-    std::vector<FakePlacesGroup*> fake_categories_;
-  };
-
-  TestLensView()
-    : lens_view_(new FakeLensView())
-  {
-  }
-
-  unity::Settings settings;
-  dash::Style style;
-  std::unique_ptr<FakeLensView> lens_view_;
-};
-
-TEST_F(TestLensView, TestCategoryInsert)
-{
-  Category cat(NULL, NULL, NULL);
-  lens_view_->OnCategoryAdded(cat);
-
-  ASSERT_TRUE(lens_view_->categories().size() > 0);
-}
-
-TEST_F(TestLensView, TestFilterExpansion)
-{
-  Category cat(NULL, NULL, NULL);
-  lens_view_->OnCategoryAdded(cat);
-  lens_view_->OnCategoryAdded(cat);
-  lens_view_->OnCategoryAdded(cat);
-
-  lens_view_->filters_expanded = true;
-  for (unsigned i = 0; i < lens_view_->fake_categories_.size(); i++)
-  {
-    EXPECT_EQ(lens_view_->fake_categories_[i]->_using_filters_background, true);
-  }
-}
-
-}
-}

=== modified file 'tests/test_main.cpp'
--- tests/test_main.cpp	2013-02-21 10:03:21 +0000
+++ tests/test_main.cpp	2013-03-21 14:03:22 +0000
@@ -6,6 +6,11 @@
 #include <config.h>
 
 #include "logger_helper.h"
+#include "test_utils.h"
+
+
+const gchar* LOCAL_DATA_DIR = BUILDDIR"/tests/data:/usr/share";
+const gchar* SCHEMA_DIRECTORY = BUILDDIR"/settings";
 
 int main(int argc, char** argv)
 {
@@ -16,6 +21,7 @@
   const std::string LOCAL_DATA_DIR = BUILDDIR"/tests/data:/usr/share";
   g_setenv("XDG_DATA_DIRS", LOCAL_DATA_DIR.c_str(), TRUE);
   g_setenv("LC_ALL", "C", TRUE);
+  Utils::init_gsettings_test_environment();
 
   gtk_init(&argc, &argv);
   setlocale(LC_ALL, "C");
@@ -33,6 +39,8 @@
   // StandaloneWindowManager brought in at link time.
   int ret = RUN_ALL_TESTS();
 
+  Utils::reset_gsettings_test_environment();
+
   return ret;
 }
 

=== modified file 'tests/test_main_dbus.cpp'
--- tests/test_main_dbus.cpp	2013-03-12 13:31:41 +0000
+++ tests/test_main_dbus.cpp	2013-03-21 14:03:22 +0000
@@ -4,9 +4,20 @@
 #include <Nux/Nux.h>
 #include "test_utils.h"
 
+#include "config.h"
+
 static bool wait_until_test_service_appears();
 static void tell_service_to_exit();
 
+static gboolean no_exit = FALSE;
+
+static GOptionEntry entries[] =
+{
+  { "no-exit", 'n', 0, G_OPTION_ARG_NONE, &no_exit, "Do not handle exit call", NULL },
+  { NULL }
+};
+
+
 int main(int argc, char** argv)
 {
   ::testing::InitGoogleTest(&argc, argv);
@@ -14,8 +25,20 @@
   g_type_init();
 #endif
 
+  GError *error = NULL;
+  GOptionContext *context;
+  context = g_option_context_new ("- DBus tests");
+  g_option_context_add_main_entries (context, entries, NULL);
+  if (!g_option_context_parse (context, &argc, &argv, &error))
+  {
+    g_print ("option parsing failed: %s\n", error->message);
+    return 1;
+  }
+  
   nux::NuxInitialize (0);
 
+  g_setenv("XDG_DATA_HOME", BUILDDIR"/tests/data", TRUE);
+
   // We need the service to be ready before we are
 
   if (!wait_until_test_service_appears())
@@ -32,7 +55,8 @@
 
   int ret = RUN_ALL_TESTS();
 
-  tell_service_to_exit();
+  if (!no_exit)
+    tell_service_to_exit();
 
   return ret;
 }

=== modified file 'tests/test_main_xless.cpp'
--- tests/test_main_xless.cpp	2013-02-21 10:03:21 +0000
+++ tests/test_main_xless.cpp	2013-03-21 14:03:22 +0000
@@ -2,6 +2,10 @@
 #include <gio/gio.h>
 #include <NuxCore/Logger.h>
 #include <Nux/Nux.h>
+#include <config.h>
+
+
+const gchar* LOCAL_DATA_DIR = BUILDDIR"/tests/data:/usr/share";
 
 int main(int argc, char** argv)
 {
@@ -11,6 +15,8 @@
 #endif
   setlocale(LC_ALL, "C");
 
+  g_setenv("XDG_DATA_DIRS", LOCAL_DATA_DIR, TRUE);
+
   // Slightly higher as we're more likely to test things we know will fail
   nux::logging::configure_logging("<root>=error");
 

=== added file 'tests/test_mock_scope.h'
--- tests/test_mock_scope.h	1970-01-01 00:00:00 +0000
+++ tests/test_mock_scope.h	2013-03-21 14:03:22 +0000
@@ -0,0 +1,178 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2013 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: Nick Dedekind <[e-mail]>
+ *
+ */
+
+#ifndef TEST_MOCK_SCOPE_H
+#define TEST_MOCK_SCOPE_H
+
+#include <gmock/gmock.h>
+#include <UnityCore/GSettingsScopes.h>
+#include <UnityCore/GLibSource.h>
+
+#include <unity-protocol.h>
+
+namespace unity
+{
+namespace dash
+{
+
+namespace
+{
+const gchar* SETTINGS_NAME = "com.canonical.Unity.Dash";
+const gchar* SCOPES_SETTINGS_KEY = "scopes";
+}
+
+// Mock Scopes for use in xless tests. (no dbus!)
+class MockScopeProxy : public ScopeProxyInterface
+{
+public:
+  MockScopeProxy(std::string const& _name, std::string const& _icon_hint)
+  : connected_(true)
+  {
+    connected.SetGetterFunction([this] () { return connected_; });
+    name.SetGetterFunction([_name] () { return _name; });
+    icon_hint.SetGetterFunction([_icon_hint] () { return _icon_hint; });
+    visible.SetGetterFunction([]() { return true; });
+  }
+
+  virtual void ConnectProxy() { connected_ = true; }
+  virtual void DisconnectProxy() { connected_ = false; }
+
+  virtual void Search(std::string const& search_hint, SearchCallback const& callback = nullptr, GCancellable* cancellable = nullptr)
+  {
+    source_manager.AddIdle([search_hint, callback] () {
+      callback(search_hint, glib::HintsMap(), glib::Error());
+      return true;
+    }, "Search");
+  }
+
+  virtual void Activate(LocalResult const& result, uint activate_type, glib::HintsMap const& hints, ActivateCallback const& callback = nullptr, GCancellable* cancellable = nullptr)
+  {
+    source_manager.AddIdle([activate_type, callback, result] ()
+    {
+      switch (activate_type)
+      {
+        case UNITY_PROTOCOL_ACTION_TYPE_ACTIVATE_RESULT:
+          callback(result, ScopeHandledType::NOT_HANDLED, glib::HintsMap(), glib::Error());
+          break;
+
+        case UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_RESULT:
+          callback(result, ScopeHandledType::SHOW_PREVIEW, glib::HintsMap(), glib::Error());
+          break;
+
+        case UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_ACTION:
+          callback(result, ScopeHandledType::HIDE_DASH, glib::HintsMap(), glib::Error());
+          break;
+
+        default:
+        {
+          glib::Error error;
+          GError** real_err = &error;
+          *real_err = g_error_new_literal(G_SCOPE_ERROR, G_SCOPE_ERROR_NO_ACTIVATION_HANDLER, "Invalid scope activation typehandler");
+          callback(result, ScopeHandledType::NOT_HANDLED, glib::HintsMap(), error);
+        } break;
+      }
+      return true;
+    }, "Activate");
+  }
+
+  virtual Results::Ptr GetResultsForCategory(unsigned category) const
+  {
+    return Results::Ptr();
+  }
+
+protected:
+  glib::SourceManager source_manager;
+  bool connected_;
+};
+
+class MockScopeData : public ScopeData
+{
+public:
+  MockScopeData(std::string const& scope_id,
+              std::string const& _dbus_name = "",
+              std::string const& _dbus_path = "")
+  {
+    id = scope_id;
+    dbus_name = _dbus_name;
+    dbus_path = _dbus_path;
+  }
+};
+
+class MockScope : public Scope
+{
+public:
+  typedef std::shared_ptr<MockScope> Ptr;
+
+  MockScope(ScopeData::Ptr const& scope_data,
+            std::string const& name = "",
+            std::string const& icon_hint = "")
+  : Scope(scope_data)
+  {
+    proxy_func = [name, icon_hint]()
+    {
+      return ScopeProxyInterface::Ptr(new MockScopeProxy(name, icon_hint));
+    };
+    
+    Init();
+  }
+
+  virtual ScopeProxyInterface::Ptr CreateProxyInterface() const
+  {
+    return proxy_func();
+  }
+
+  std::function<ScopeProxyInterface::Ptr(void)> proxy_func;
+};
+
+class MockGSettingsScopes : public GSettingsScopes
+{
+public:
+  MockGSettingsScopes(const char* scopes_settings[])
+  {
+    gsettings_client = g_settings_new(SETTINGS_NAME);
+    UpdateScopes(scopes_settings);
+  }
+
+  using GSettingsScopes::InsertScope;
+  using GSettingsScopes::RemoveScope;
+
+  void UpdateScopes(const char* scopes_settings[])
+  {
+    g_settings_set_strv(gsettings_client, SCOPES_SETTINGS_KEY, scopes_settings);
+  }
+
+protected:
+  virtual Scope::Ptr CreateScope(ScopeData::Ptr const& scope_data)
+  {
+    Scope::Ptr scope(new MockScope(scope_data));
+    return scope;
+  }
+
+private:
+  glib::Object<GSettings> gsettings_client;
+};
+
+} // namesapce dash
+} // namesapce unity
+
+
+#endif // TEST_MOCK_SCOPE_H

=== modified file 'tests/test_model_iterator.cpp'
--- tests/test_model_iterator.cpp	2013-03-19 14:05:51 +0000
+++ tests/test_model_iterator.cpp	2013-03-21 14:03:22 +0000
@@ -110,6 +110,20 @@
   EXPECT_NE(one, two);
 }
 
+TEST_F(TestResultIterator, TestEqual)
+{
+  AddResult("mailto:[e-mail]", "Email");
+
+  ResultIterator one(results->model());
+  ResultIterator two = one;
+
+  EXPECT_EQ(one, two);
+
+  ResultIterator const& original = two++;
+  EXPECT_EQ(original, one);
+  EXPECT_NE(one, two);
+}
+
 TEST_F(TestResultIterator, TestIncrement)
 {
   AddResult("file:///foo.txt", "Result #1");
@@ -129,5 +143,77 @@
   EXPECT_FALSE(it.IsFirst());
 }
 
-
+TEST_F(TestResultIterator, TestDecrement)
+{
+  AddResult("file:///foo.txt", "Result #1");
+  AddResult("file:///qoo.txt", "Result #2");
+
+  ResultIterator it(results->end());
+  EXPECT_TRUE(it.IsLast());
+
+  it--;
+  EXPECT_EQ((*it).uri, "file:///qoo.txt");
+  EXPECT_EQ((*it).name, "Result #2");
+
+  it--;
+  EXPECT_EQ((*it).uri, "file:///foo.txt");
+  EXPECT_EQ((*it).name, "Result #1");
+
+  EXPECT_TRUE(it.IsFirst());
+  EXPECT_FALSE(it.IsLast());
+}
+
+TEST_F(TestResultIterator, TestAdd)
+{
+  AddResult("file:///foo.txt", "Result #1");
+  AddResult("file:///qoo.txt", "Result #2");
+  AddResult("file:///bar.txt", "Result #3");
+
+  ResultIterator it(results->model());
+  EXPECT_EQ((*it).uri, "file:///foo.txt");
+  EXPECT_EQ((*it).name, "Result #1");
+
+  it+=2;
+  EXPECT_EQ((*it).uri, "file:///bar.txt");
+  EXPECT_EQ((*it).name, "Result #3");
+  EXPECT_FALSE(it.IsLast());
+
+  it+=1;
+  EXPECT_TRUE(it.IsLast());
+  EXPECT_FALSE(it.IsFirst());
+}
+
+TEST_F(TestResultIterator, TestSubtract)
+{
+  AddResult("file:///foo.txt", "Result #1");
+  AddResult("file:///qoo.txt", "Result #2");
+  AddResult("file:///bar.txt", "Result #3");
+
+  ResultIterator it(results->end());
+  EXPECT_TRUE(it.IsLast());
+
+  it--;
+  EXPECT_EQ((*it).uri, "file:///bar.txt");
+  EXPECT_EQ((*it).name, "Result #3");
+
+  it-=2;
+  EXPECT_EQ((*it).uri, "file:///foo.txt");
+  EXPECT_EQ((*it).name, "Result #1");
+  EXPECT_TRUE(it.IsFirst());
+  EXPECT_FALSE(it.IsLast());
+}
+
+TEST_F(TestResultIterator, TestOperatorAt)
+{
+  AddResult("file:///foo.txt", "Result #1");
+  AddResult("file:///qoo.txt", "Result #2");
+  AddResult("file:///bar.txt", "Result #3");
+
+  ResultIterator it(results->begin());
+  it = it[1];
+
+  EXPECT_EQ((*it).uri, "file:///qoo.txt");
+  EXPECT_EQ((*it).name, "Result #2");
 } // Namespace
+
+}

=== added file 'tests/test_preview_player.cpp'
--- tests/test_preview_player.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_preview_player.cpp	2013-03-21 14:03:22 +0000
@@ -0,0 +1,151 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include <gmock/gmock.h>
+#include "UnityCore/PreviewPlayer.h"
+#include "test_utils.h"
+#include "config.h"
+#include "sigc++/connection.h"
+
+namespace unity
+{
+
+const gchar* WHITE_NOISE = "file://" BUILDDIR "/tests/data/unity/sounds/whitenoise.mp3";
+
+
+namespace
+{
+  void PlayAndWait(PreviewPlayer* player, std::string const& uri)
+  {
+    bool play_returned = false;
+    auto play_callback = [&play_returned] (glib::Error const& error) {
+      play_returned = true;
+      EXPECT_TRUE(!error) << "Error: " << error.Message();
+    };
+
+    bool updated_called = false;
+    auto updated_callback = [uri, &updated_called] (std::string const& _uri, PlayerState state, double) {
+      updated_called = true;
+      EXPECT_EQ(_uri, uri) << "Uri for PLAY not correct (" << _uri << " != " << _uri << ")";
+      EXPECT_EQ((int)state, (int)PlayerState::PLAYING) << "Incorrect state returned on PLAY.";
+    };
+
+    sigc::connection conn = player->updated.connect(updated_callback);
+    player->Play(uri, play_callback);
+    ::Utils::WaitUntilMSec(play_returned, 3000, []() { return g_strdup("PLAY did not return"); });
+    ::Utils::WaitUntilMSec(updated_called, 5000, []() { return g_strdup("Update not called on PLAY"); });
+    conn.disconnect();
+  }
+
+  void PauseAndWait(PreviewPlayer* player)
+  {
+    bool pause_returned = false;
+    auto callback = [&pause_returned] (glib::Error const& error) {
+      pause_returned = true;
+      EXPECT_TRUE(!error) << "Error: " << error.Message();
+    };
+
+    bool updated_called = false;
+    auto updated_callback = [&updated_called] (std::string const&, PlayerState state, double) {
+      updated_called = true;
+      EXPECT_EQ((int)state, (int)PlayerState::PAUSED) << "Incorrect state returned on PAUSE.";
+    };
+
+    sigc::connection conn = player->updated.connect(updated_callback);
+    player->Pause(callback);
+    ::Utils::WaitUntilMSec(pause_returned, 3000, []() { return g_strdup("PAUSE did not return"); });
+    ::Utils::WaitUntilMSec(updated_called, 5000, []() { return g_strdup("Update not called om PAUSE"); });
+    conn.disconnect();
+  }
+
+  void ResumeAndWait(PreviewPlayer* player)
+  {
+    bool resume_returned = false;
+    auto callback = [&resume_returned] (glib::Error const& error) {
+      resume_returned = true;
+      EXPECT_TRUE(!error) << "Error: " << error.Message();
+    };
+
+    bool updated_called = false;
+    auto updated_callback = [&updated_called] (std::string const&, PlayerState state, double) {
+      updated_called = true;
+      EXPECT_EQ((int)state, (int)PlayerState::PLAYING) << "Incorrect state returned on RESUME.";
+    };
+
+    sigc::connection conn = player->updated.connect(updated_callback);
+    player->Resume(callback);
+    ::Utils::WaitUntilMSec(resume_returned, 3000, []() { return g_strdup("RESUME did not return"); });
+    ::Utils::WaitUntilMSec(updated_called, 5000, []() { return g_strdup("Update not called on RESUME"); });
+    conn.disconnect();
+  }
+
+  void StopAndWait(PreviewPlayer* player)
+  {
+    bool stop_returned = false;
+    auto callback = [&stop_returned] (glib::Error const& error) {
+      stop_returned = true;
+      EXPECT_TRUE(!error) << "Error: " << error.Message();
+    };
+
+    bool updated_called = false;
+    auto updated_callback = [&updated_called] (std::string const&, PlayerState state, double) {
+      updated_called = true;
+      EXPECT_EQ((int)state, (int)PlayerState::STOPPED) << "Incorrect state returned on STOP.";
+    };
+
+    sigc::connection conn = player->updated.connect(updated_callback);
+    player->Stop(callback);
+    ::Utils::WaitUntilMSec(stop_returned, 3000, []() { return g_strdup("STOP did not return"); });
+    ::Utils::WaitUntilMSec(updated_called, 5000, []() { return g_strdup("Update not called on STOP"); });
+    conn.disconnect();
+  }
+}
+
+TEST(TestPreviewPlayer, TestConstruct)
+{
+  PreviewPlayer player1;
+  PreviewPlayer player2;
+}
+
+TEST(TestPreviewPlayer, TestPlayerControl)
+{
+  PreviewPlayer player;
+
+  PlayAndWait(&player, WHITE_NOISE);
+
+  PauseAndWait(&player);
+
+  ResumeAndWait(&player);
+
+  StopAndWait(&player);
+}
+
+TEST(TestPreviewPlayer, TestMultiPlayer)
+{
+  PreviewPlayer player1;
+  {
+    PreviewPlayer player2;
+    PlayAndWait(&player2, WHITE_NOISE);
+  }
+
+  StopAndWait(&player1);
+}
+
+
+} // namespace unity
\ No newline at end of file

=== modified file 'tests/test_results.cpp'
--- tests/test_results.cpp	2013-03-19 14:05:51 +0000
+++ tests/test_results.cpp	2013-03-21 14:03:22 +0000
@@ -74,10 +74,21 @@
     EXPECT_EQ(result.uri(), value);
     EXPECT_EQ(result.icon_hint(), value);
     EXPECT_EQ(result.category_index(), (i / 50));
+    EXPECT_EQ(result.result_type(), 0);
     EXPECT_EQ(result.mimetype(), value);
     EXPECT_EQ(result.name(), value);
     EXPECT_EQ(result.comment(), value);
     EXPECT_EQ(result.dnd_uri(), value);
+
+    glib::HintsMap hints = result.hints();
+    auto iter = hints.find("key");
+    EXPECT_TRUE(iter != hints.end());
+    if (iter != hints.end())
+    {
+      std::string value = glib::gchar_to_string(g_variant_get_string(iter->second, NULL));
+      EXPECT_EQ(value, "value");
+    }
+
     i++;
   }
 
@@ -156,4 +167,133 @@
   }
 }
 
+// We're testing the model's ability to store and retrieve random pointers
+TEST(TestResults, TestResultEqual)
+{
+  Results model;
+  model.swarm_name = swarm_name;
+
+  WaitForSynchronize(model);
+
+  Result result_1(*model.begin());
+  Result result_2(NULL, NULL, NULL);
+  result_2 = result_1;
+
+  EXPECT_EQ(result_2.uri(), result_1.uri());
+  EXPECT_EQ(result_2.icon_hint(), result_1.icon_hint());
+  EXPECT_EQ(result_2.category_index(), result_1.category_index());
+  EXPECT_EQ(result_2.result_type(), result_1.result_type());
+  EXPECT_EQ(result_2.mimetype(), result_1.mimetype());
+  EXPECT_EQ(result_2.name(), result_1.name());
+  EXPECT_EQ(result_2.comment(), result_1.comment());
+  EXPECT_EQ(result_2.dnd_uri(), result_1.dnd_uri());
+}
+
+// We're testing the model's ability to store and retrieve random pointers
+TEST(TestResults, LocalResult_Construct)
+{
+  Results model;
+  model.swarm_name = swarm_name;
+
+  WaitForSynchronize(model);
+
+  ResultIterator iter(model.model);
+  for (Result const& result : model)
+  {
+    LocalResult local_result_1(result);
+    LocalResult local_result_2(local_result_1);
+
+    EXPECT_EQ(local_result_1.uri, result.uri());
+    EXPECT_EQ(local_result_1.icon_hint, result.icon_hint());
+    EXPECT_EQ(local_result_1.category_index, result.category_index());
+    EXPECT_EQ(local_result_1.result_type, result.result_type());
+    EXPECT_EQ(local_result_1.mimetype, result.mimetype());
+    EXPECT_EQ(local_result_1.name, result.name());
+    EXPECT_EQ(local_result_1.comment, result.comment());
+    EXPECT_EQ(local_result_1.dnd_uri, result.dnd_uri());
+
+    EXPECT_EQ(local_result_2.uri, result.uri());
+    EXPECT_EQ(local_result_2.icon_hint, result.icon_hint());
+    EXPECT_EQ(local_result_2.category_index, result.category_index());
+    EXPECT_EQ(local_result_2.result_type, result.result_type());
+    EXPECT_EQ(local_result_2.mimetype, result.mimetype());
+    EXPECT_EQ(local_result_2.name, result.name());
+    EXPECT_EQ(local_result_2.comment, result.comment());
+    EXPECT_EQ(local_result_2.dnd_uri, result.dnd_uri());
+  }
+}
+
+
+// We're testing the model's ability to store and retrieve random pointers
+TEST(TestResults, LocalResult_OperatorEqual)
+{
+  Results model;
+  model.swarm_name = swarm_name;
+
+  WaitForSynchronize(model);
+
+  ResultIterator iter(model.model);
+  for (Result const& result : model)
+  {
+    LocalResult local_result_1(result);
+    LocalResult local_result_2(local_result_1);
+
+    EXPECT_TRUE(local_result_1 == local_result_2);
+    EXPECT_FALSE(local_result_1 != local_result_2);
+  }
+}
+
+
+// We're testing the model's ability to store and retrieve random pointers
+TEST(TestResults, LocalResult_FromToVariant)
+{
+  LocalResult local_result_1;
+  local_result_1.uri = "uri";
+  local_result_1.icon_hint = "icon_hint";
+  local_result_1.category_index = 1;
+  local_result_1.result_type = 2;
+  local_result_1.mimetype = "mimetype";
+  local_result_1.name = "name";
+  local_result_1.comment = "comment";
+  local_result_1.dnd_uri = "dnd_uri";
+  
+  local_result_1.hints["key1"] = g_variant_new_string("value1");
+  local_result_1.hints["key2"] = g_variant_new_string("value2");
+
+  glib::Variant variant_value = local_result_1.Variant();
+  LocalResult local_result_2 = LocalResult::FromVariant(variant_value);
+
+  EXPECT_EQ(local_result_2.uri, "uri");
+  EXPECT_EQ(local_result_2.icon_hint, "icon_hint");
+  EXPECT_EQ(local_result_2.category_index, 1);
+  EXPECT_EQ(local_result_2.result_type, 2);
+  EXPECT_EQ(local_result_2.mimetype, "mimetype");
+  EXPECT_EQ(local_result_2.name, "name");
+  EXPECT_EQ(local_result_2.comment, "comment");
+  EXPECT_EQ(local_result_2.dnd_uri, "dnd_uri");
+
+  auto iter = local_result_2.hints.find("key1");
+  EXPECT_TRUE(iter != local_result_2.hints.end());
+  if (iter != local_result_2.hints.end())
+  {
+    std::string value = glib::gchar_to_string(g_variant_get_string(iter->second, NULL));
+    EXPECT_EQ(value, "value1");
+  }
+  iter = local_result_2.hints.find("key2");
+  EXPECT_TRUE(iter != local_result_2.hints.end());
+  if (iter != local_result_2.hints.end())
+  {
+    std::string value = glib::gchar_to_string(g_variant_get_string(iter->second, NULL));
+    EXPECT_EQ(value, "value2");
+  }
+}
+
+
+// We're testing the model's ability to store and retrieve random pointers
+TEST(TestResults, LocalResult_Variants)
+{
+  LocalResult local_result;
+  EXPECT_EQ(local_result.Variants().size(), 9);
+}
+
 }

=== modified file 'tests/test_resultviewgrid.cpp'
--- tests/test_resultviewgrid.cpp	2013-02-21 10:03:21 +0000
+++ tests/test_resultviewgrid.cpp	2013-03-21 14:03:22 +0000
@@ -49,7 +49,7 @@
 public:
   virtual void SetUp()
   {
-    view.Adopt(new MockResultViewGrid(NUX_TRACKER_LOCATION));
+    view.Adopt(new NiceMock<MockResultViewGrid>(NUX_TRACKER_LOCATION));
     renderer.Adopt(new dash::ResultRenderer(NUX_TRACKER_LOCATION));
 
     view->SetModelRenderer(renderer.GetPointer());

=== added file 'tests/test_scope.cpp'
--- tests/test_scope.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_scope.cpp	2013-03-21 14:03:22 +0000
@@ -0,0 +1,236 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include <boost/lexical_cast.hpp>
+#include <gtest/gtest.h>
+#include <glib-object.h>
+#include <unity-protocol.h>
+
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/Scope.h>
+ #include <UnityCore/CheckOptionFilter.h>
+
+#include "test_utils.h"
+#include "RadioOptionFilter.h"
+
+using namespace std;
+using namespace unity;
+using namespace unity::dash;
+
+namespace unity
+{
+namespace dash
+{
+
+namespace
+{
+const std::string SCOPE_NAME = "testscope1.scope";
+}
+
+class TestScope : public ::testing::Test
+{
+public:
+  TestScope() { }
+
+  virtual void SetUp()
+  {
+    glib::Error err;
+    ScopeData::Ptr data(ScopeData::ReadProtocolDataForId(SCOPE_NAME, err));
+    ASSERT_TRUE(err ? false : true);
+
+    scope_.reset(new Scope(data));
+    scope_->Init();
+  }
+ 
+  void ConnectAndWait()
+  {
+    scope_->Connect();
+    Utils::WaitUntilMSec([this] { return scope_->connected() == true; }, true, 2000);
+  }
+
+  Filter::Ptr WaitForFilter(std::string const& filter_to_wait_for)
+  {
+    Filter::Ptr filter_ret;
+    Filters::Ptr filters = scope_->filters();    
+    Utils::WaitUntilMSec([filters, filter_to_wait_for, &filter_ret]
+                         {
+                           for (std::size_t i = 0; i < filters->count(); i++)
+                           {
+                             Filter::Ptr filter = filters->FilterAtIndex(i);
+                             if (filter && filter->id == filter_to_wait_for)
+                             {
+                               filter_ret = filter;
+                               return true;
+                             }
+                           }
+                           return false;
+                         },
+                         true,
+                         2000,
+                         [filter_to_wait_for] { return g_strdup_printf("Filter '%s' not found", filter_to_wait_for.c_str()); });
+    return filter_ret;
+  }
+
+  Scope::Ptr scope_;
+};
+
+TEST_F(TestScope, TestConnection)
+{
+  ConnectAndWait();
+  ASSERT_TRUE(scope_->connected);
+}
+
+TEST_F(TestScope, Search)
+{
+  // Auto-connect on search
+  bool search_ok = false;
+  auto search_callback = [&search_ok] (std::string const& search_string, glib::HintsMap const&, glib::Error const&) {
+    search_ok = true;
+  };
+
+  scope_->Search("12:test_search", search_callback, nullptr);
+  Utils::WaitUntilMSec(search_ok,
+                       2000,
+                       [] { return g_strdup("Search did not finish sucessfully"); });
+}
+
+TEST_F(TestScope, ActivateUri)
+{
+  // Auto-connect on activate
+  bool activated_return = false;
+  auto activate_callback = [&activated_return] (LocalResult const&, ScopeHandledType, glib::Error const&) {
+    activated_return = true;
+  };
+
+  LocalResult result; result.uri = "file:://test";
+  scope_->Activate(result,
+                   activate_callback);
+
+  Utils::WaitUntilMSec(activated_return,
+                       2000,
+                       [] { return g_strdup("Failed to activate"); });
+}
+
+TEST_F(TestScope, PreviewPerformAction)
+{
+  Preview::Ptr preview;
+  // Auto-connect on preview
+  bool preview_ok = false;
+  auto preview_callback = [&preview_ok, &preview] (LocalResult const&, Preview::Ptr const& _preview, glib::Error const&) {
+    preview_ok = true;
+    preview = _preview;
+  };
+
+  LocalResult result; result.uri = "file:://test";
+  scope_->Preview(result,
+                  preview_callback);
+
+  Utils::WaitUntilMSec(preview_ok,
+                       2000,
+                       [] { return g_strdup("Failed to preview"); });
+  EXPECT_TRUE(preview ? true : false);
+  if (preview)
+  {
+    Preview::ActionPtrList actions = preview->GetActions();
+    // EXPECT_TRUE(actions.size() > 0);
+    for (auto action : actions)
+      preview->PerformAction(action->id);    
+  }
+}
+
+TEST_F(TestScope, ActivatePreviewAction)
+{
+  // Auto-connect on preview
+  bool preview_action_ok = false;
+  auto preview_action_callback = [&preview_action_ok] (LocalResult const&, ScopeHandledType, glib::Error const&) {
+    preview_action_ok = true;
+  };
+
+  LocalResult result; result.uri = "file:://test";
+  scope_->ActivatePreviewAction("play",
+                                result,
+                                glib::HintsMap(),
+                                preview_action_callback);
+
+  Utils::WaitUntilMSec(preview_action_ok,
+                       2000,
+                       [] { return g_strdup("Failed to activate preview action"); });
+}
+
+TEST_F(TestScope, UpdateSearchCategoryWorkflow)
+{
+  bool search_ok = false;
+  bool search_finished = false;
+  auto search_callback = [&search_ok, &search_finished] (std::string const& search_string, glib::HintsMap const&, glib::Error const& error) {
+    search_finished = true;
+    search_ok = error ? false : true;
+  };
+
+  // 1. First search
+  scope_->Search("13:cat", search_callback);
+
+  Results::Ptr results = scope_->results();
+  Utils::WaitUntilMSec(search_ok, 2000, [] { return g_strdup("First search failed."); });
+  Utils::WaitUntilMSec([results] { return results->count() == 13; },
+                       true,
+                       2000,
+                       [results] { return g_strdup_printf("First search. Either search didn't finish, or result count is not as expected (%u != 13).", static_cast<int>(results->count())); });
+  EXPECT_EQ(search_ok, true);
+
+  Results::Ptr category_model0 = scope_->GetResultsForCategory(0);
+  Results::Ptr category_model1 = scope_->GetResultsForCategory(1);
+  Results::Ptr category_model2 = scope_->GetResultsForCategory(2);
+
+  EXPECT_EQ(category_model0->count(), 5) << "Category 0 result count not as expected (" << category_model0->count() << " != 5)";
+  EXPECT_EQ(category_model1->count(), 4) << "Category 1 result count not as expected (" << category_model1->count() << " != 4)";
+  EXPECT_EQ(category_model2->count(), 4) << "Category 2 result count not as expected (" << category_model2->count() << " != 4)";
+
+  // 2. Update the filter.
+  CheckOptionFilter::Ptr type_filter = std::static_pointer_cast<CheckOptionFilter>(WaitForFilter("categories"));
+  ASSERT_TRUE(type_filter ? true : false);
+
+  bool filter_updated = false;
+  std::vector<FilterOption::Ptr> options = type_filter->options();
+  for (FilterOption::Ptr const& option : options)
+  {
+    if (option->id == "cat1")
+    {
+      option->active = true;
+      filter_updated = true;
+    }
+  }
+  EXPECT_TRUE(filter_updated) << "Could not update filter opiton 'cat1' of filter 'categories'";
+
+  // Results should be updated for fulter.
+  Utils::WaitUntilMSec([results] { return results->count() == 4; },
+                       true,
+                       2000,
+                       [results] { return g_strdup_printf("First search. Either search didn't finish, or result count is not as expected (%u != 4).", static_cast<int>(results->count())); });
+
+  category_model0 = scope_->GetResultsForCategory(0);
+  category_model1 = scope_->GetResultsForCategory(1);
+  category_model2 = scope_->GetResultsForCategory(2);
+
+  EXPECT_EQ(category_model0->count(), 0) << "Category 0 result count not as expected (" << category_model0->count() << " != 0)";
+  EXPECT_EQ(category_model1->count(), 4) << "Category 1 result count not as expected (" << category_model1->count() << " != 4)";
+  EXPECT_EQ(category_model2->count(), 0) << "Category 2 result count not as expected (" << category_model2->count() << " != 0)";
+}
+
+} // namespace dash
+} // namespace unity

=== added file 'tests/test_scope_bar.cpp'
--- tests/test_scope_bar.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_scope_bar.cpp	2013-03-21 14:03:22 +0000
@@ -0,0 +1,134 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <dash/ScopeBar.h>
+
+#include "unity-shared/DashStyle.h"
+#include "unity-shared/UnitySettings.h"
+#include "test_mock_scope.h"
+
+using namespace unity;
+using namespace unity::dash;
+
+namespace unity
+{
+namespace dash
+{
+
+class TestScopeBar : public ::testing::Test
+{
+public:
+  TestScopeBar()
+  {
+  }
+
+  void CheckSize(ScopeBar const& scope_bar, int size)
+  {
+    EXPECT_EQ(scope_bar.icons_.size(), size);
+  }
+
+  unity::Settings settings;
+  dash::Style style;
+};
+
+TEST_F(TestScopeBar, TestAddScopes)
+{
+  ScopeBar scope_bar;
+
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope1.scope"), "TestScope1", "icon-sub1.svg"));
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope2.scope"), "TestScope2", "icon-sub2.svg"));
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope3.scope"), "TestScope3", "icon-sub3.svg"));
+
+  CheckSize(scope_bar, 3);
+}
+
+TEST_F(TestScopeBar, TestActivate)
+{
+  ScopeBar scope_bar;
+
+  std::string active_scope = "";
+  scope_bar.scope_activated.connect([&active_scope](std::string const& activated) { active_scope = activated; } );
+
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope1.scope"), "TestScope1", "icon-sub1.svg"));
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope2.scope"), "TestScope2", "icon-sub2.svg"));
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope3.scope"), "TestScope3", "icon-sub3.svg"));
+
+  scope_bar.Activate("testscope1.scope");
+  EXPECT_EQ(active_scope, "testscope1.scope");
+
+  scope_bar.Activate("testscope2.scope");
+  EXPECT_EQ(active_scope, "testscope2.scope");
+
+  scope_bar.Activate("testscope3.scope");
+  EXPECT_EQ(active_scope, "testscope3.scope");
+}
+
+TEST_F(TestScopeBar, TestActivateNext)
+{
+  ScopeBar scope_bar;
+
+  std::string active_scope = "";
+  scope_bar.scope_activated.connect([&active_scope](std::string const& activated) { active_scope = activated; } );
+
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope1.scope"), "TestScope1", "icon-sub1.svg"));
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope2.scope"), "TestScope2", "icon-sub2.svg"));
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope3.scope"), "TestScope3", "icon-sub3.svg"));
+
+  scope_bar.ActivateNext();
+  EXPECT_EQ(active_scope, "testscope1.scope");
+
+  scope_bar.ActivateNext();
+  EXPECT_EQ(active_scope, "testscope2.scope");
+
+  scope_bar.ActivateNext();
+  EXPECT_EQ(active_scope, "testscope3.scope");
+
+  scope_bar.ActivateNext();
+  EXPECT_EQ(active_scope, "testscope1.scope");
+}
+
+TEST_F(TestScopeBar, TestActivatePrevious)
+{
+  ScopeBar scope_bar;
+
+  std::string active_scope = "";
+  scope_bar.scope_activated.connect([&active_scope](std::string const& activated) { active_scope = activated; } );
+
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope1.scope"), "TestScope1", "icon-sub1.svg"));
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope2.scope"), "TestScope2", "icon-sub2.svg"));
+  scope_bar.AddScope(std::make_shared<MockScope>(std::make_shared<MockScopeData>("testscope3.scope"), "TestScope3", "icon-sub3.svg"));
+
+  scope_bar.ActivatePrevious();
+  EXPECT_EQ(active_scope, "testscope3.scope");
+
+  scope_bar.ActivatePrevious();
+  EXPECT_EQ(active_scope, "testscope2.scope");
+
+  scope_bar.ActivatePrevious();
+  EXPECT_EQ(active_scope, "testscope1.scope");
+
+  scope_bar.ActivatePrevious();
+  EXPECT_EQ(active_scope, "testscope3.scope");
+}
+
+
+}
+}

=== added file 'tests/test_scope_data.cpp'
--- tests/test_scope_data.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_scope_data.cpp	2013-03-21 14:03:22 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include <gtest/gtest.h>
+#include <glib-object.h>
+#include "test_utils.h"
+#include "UnityCore/ScopeData.cpp"
+
+using namespace std;
+using namespace unity;
+using namespace unity::dash;
+
+namespace
+{
+
+// A new one of these is created for each test
+class TestScopeData : public testing::Test
+{
+public:
+  TestScopeData()
+  {}
+};
+
+TEST_F(TestScopeData, TestReadExisting)
+{
+  glib::Error error;
+  ScopeData::Ptr scope_data(ScopeData::ReadProtocolDataForId("testscope1.scope", error));
+  ASSERT_TRUE(scope_data && !error);
+
+  EXPECT_EQ(scope_data->id(),                  "testscope1.scope");
+  EXPECT_EQ(scope_data->name(),                "TestScope1");
+  EXPECT_EQ(scope_data->dbus_name(),           "com.canonical.Unity.Test.Scope");
+  EXPECT_EQ(scope_data->dbus_path(),           "/com/canonical/unity/scope/testscope1");
+  EXPECT_EQ(scope_data->icon_hint(),           "/usr/share/unity/6/icon-sub1.svg");
+  EXPECT_EQ(scope_data->category_icon_hint(),  "");
+  EXPECT_EQ(scope_data->type(),                "varia");
+  EXPECT_EQ(scope_data->query_pattern(),       "^@");
+  EXPECT_EQ(scope_data->description(),         "Find various stuff 1");
+  EXPECT_EQ(scope_data->shortcut(),            "q");
+  EXPECT_EQ(scope_data->search_hint(),         "Search stuff 1");
+  EXPECT_TRUE(scope_data->keywords().size() == 1 && scope_data->keywords().front()=="misc");
+  // EXPECT_EQ(scope_data->full_path(),           "");
+}
+
+TEST_F(TestScopeData, TestNonExisting)
+{
+  glib::Error error;
+  ScopeData::Ptr scope_data(ScopeData::ReadProtocolDataForId("non-existing.scope", error));
+  EXPECT_TRUE(scope_data && error);
+}
+
+}

=== added file 'tests/test_scope_filter.cpp'
--- tests/test_scope_filter.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_scope_filter.cpp	2013-03-21 14:03:22 +0000
@@ -0,0 +1,335 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include <boost/lexical_cast.hpp>
+#include <gtest/gtest.h>
+#include <glib-object.h>
+#include <unity-protocol.h>
+
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/Scope.h>
+#include <UnityCore/Variant.h>
+
+#include <UnityCore/CheckOptionFilter.h>
+#include <UnityCore/MultiRangeFilter.h>
+#include <UnityCore/RadioOptionFilter.h>
+#include <UnityCore/RatingsFilter.h>
+
+#include "test_utils.h"
+
+using namespace std;
+using namespace unity;
+using namespace unity::dash;
+
+namespace unity
+{
+namespace dash
+{
+
+namespace
+{
+const std::string SCOPE_NAME = "testscope1.scope";
+}
+
+class TestScopeFilter : public ::testing::Test
+{
+public:
+  TestScopeFilter() { }
+
+  virtual void SetUp()
+  {
+    glib::Error err;
+    ScopeData::Ptr data(ScopeData::ReadProtocolDataForId(SCOPE_NAME, err));
+    ASSERT_TRUE(err ? false : true);
+
+    scope_.reset(new Scope(data));
+    scope_->Init();
+    ConnectAndWait();
+  }
+ 
+  void ConnectAndWait()
+  {
+    scope_->Connect();
+    Utils::WaitUntilMSec([this] { return scope_->connected() == true; }, true, 2000);
+  }
+
+  void WaitForSynchronize(Filters::Ptr const& model, unsigned int count)
+  {
+    Utils::WaitUntil([model,count] { return model->count == count; });
+  }
+
+  Scope::Ptr scope_;
+};
+
+TEST_F(TestScopeFilter, TestFilterCheckOption)
+{
+  Filters::Ptr filters = scope_->filters;
+  WaitForSynchronize(filters, 4);
+
+  CheckOptionFilter::Ptr filter = static_pointer_cast<CheckOptionFilter>(filters->FilterAtIndex(0));
+  EXPECT_EQ(filter->id, "categories");
+  EXPECT_EQ(filter->name, "Categories");
+  EXPECT_EQ(filter->icon_hint, "");
+  EXPECT_EQ(filter->renderer_name, "filter-checkoption");
+  EXPECT_TRUE(filter->visible);
+  EXPECT_FALSE(filter->collapsed);
+  EXPECT_FALSE(filter->filtering);
+
+  CheckOptionFilter::CheckOptions options = filter->options;
+  EXPECT_EQ(options.size(), (unsigned int)3);
+  
+  EXPECT_EQ(options[0]->id, "cat0");
+  EXPECT_EQ(options[0]->name, "Category 0");
+  EXPECT_EQ(options[0]->icon_hint, "gtk-cdrom");
+  EXPECT_FALSE(options[0]->active);
+
+  EXPECT_EQ(options[1]->id, "cat1");
+  EXPECT_EQ(options[1]->name, "Category 1");
+  EXPECT_EQ(options[1]->icon_hint, "gtk-directory");
+  EXPECT_FALSE(options[1]->active);
+
+  EXPECT_EQ(options[2]->id, "cat2");
+  EXPECT_EQ(options[2]->name, "Category 2");
+  EXPECT_EQ(options[2]->icon_hint, "gtk-clear");
+  EXPECT_FALSE(options[2]->active);
+}
+
+TEST_F(TestScopeFilter, TestFilterCheckOptionLogic)
+{
+  Filters::Ptr filters = scope_->filters;
+  WaitForSynchronize(filters, 4);
+
+  CheckOptionFilter::Ptr filter = static_pointer_cast<CheckOptionFilter>(filters->FilterAtIndex(0));
+  CheckOptionFilter::CheckOptions options = filter->options;
+
+  EXPECT_FALSE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+
+  options[0]->active = true;
+  options[0]->active = false;
+  EXPECT_FALSE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+
+  options[0]->active = true;
+  EXPECT_TRUE (filter->filtering);
+  EXPECT_TRUE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+
+  options[1]->active = true;
+  EXPECT_TRUE (filter->filtering);
+  EXPECT_TRUE (options[0]->active);
+  EXPECT_TRUE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+
+  options[2]->active = true;
+  EXPECT_TRUE (filter->filtering);
+  EXPECT_TRUE (options[0]->active);
+  EXPECT_TRUE (options[1]->active);
+  EXPECT_TRUE (options[2]->active);
+
+  filter->Clear();
+  EXPECT_FALSE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+}
+
+TEST_F(TestScopeFilter, TestFilterRadioOption)
+{
+  Filters::Ptr filters = scope_->filters;
+  WaitForSynchronize(filters, 4);
+
+  RadioOptionFilter::Ptr filter = static_pointer_cast<RadioOptionFilter>(filters->FilterAtIndex(1));
+  EXPECT_EQ(filter->id, "when");
+  EXPECT_EQ(filter->name, "When");
+  EXPECT_EQ(filter->icon_hint, "");
+  EXPECT_EQ(filter->renderer_name, "filter-radiooption");
+  EXPECT_TRUE(filter->visible);
+  EXPECT_FALSE(filter->collapsed);
+  EXPECT_FALSE(filter->filtering);
+
+  RadioOptionFilter::RadioOptions options = filter->options;
+  EXPECT_EQ(options.size(), (unsigned int)3);
+  
+  EXPECT_EQ(options[0]->id, "today");
+  EXPECT_EQ(options[0]->name, "Today");
+  EXPECT_EQ(options[0]->icon_hint, "");
+  EXPECT_FALSE(options[0]->active);
+
+  EXPECT_EQ(options[1]->id, "yesterday");
+  EXPECT_EQ(options[1]->name, "Yesterday");
+  EXPECT_EQ(options[1]->icon_hint, "");
+  EXPECT_FALSE(options[1]->active);
+
+  EXPECT_EQ(options[2]->id, "lastweek");
+  EXPECT_EQ(options[2]->name, "Last Week");
+  EXPECT_EQ(options[2]->icon_hint, "");
+  EXPECT_FALSE(options[2]->active);
+}
+
+TEST_F(TestScopeFilter, TestFilterRadioOptionLogic)
+{
+  Filters::Ptr filters = scope_->filters;
+  WaitForSynchronize(filters, 4);
+
+  RadioOptionFilter::Ptr filter = static_pointer_cast<RadioOptionFilter>(filters->FilterAtIndex(1));
+  RadioOptionFilter::RadioOptions options = filter->options;
+
+  EXPECT_FALSE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+
+  options[0]->active = true;
+  options[0]->active = false;
+  EXPECT_FALSE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+
+  options[0]->active = true;
+  EXPECT_TRUE (filter->filtering);
+  EXPECT_TRUE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+
+  options[1]->active = true;
+  EXPECT_TRUE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_TRUE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+
+  options[2]->active = true;
+  EXPECT_TRUE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_TRUE (options[2]->active);
+
+  filter->Clear();
+  EXPECT_FALSE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+}
+
+TEST_F(TestScopeFilter, TestFilterRatings)
+{
+  Filters::Ptr filters = scope_->filters;
+  WaitForSynchronize(filters, 4);
+
+  RatingsFilter::Ptr filter = static_pointer_cast<RatingsFilter>(filters->FilterAtIndex(2));
+  EXPECT_EQ(filter->id, "ratings");
+  EXPECT_EQ(filter->name, "Ratings");
+  EXPECT_EQ(filter->icon_hint, "");
+  std::string tmp = filter->renderer_name;
+  EXPECT_EQ(filter->renderer_name, "filter-ratings");
+  EXPECT_TRUE(filter->visible);
+  EXPECT_FALSE(filter->collapsed);
+  EXPECT_FALSE(filter->filtering);
+
+  EXPECT_FLOAT_EQ(filter->rating, 0.0f);
+  filter->rating = 0.5f;
+  EXPECT_FLOAT_EQ(filter->rating, 0.5f);
+}
+
+TEST_F(TestScopeFilter, TestFilterMultiRange)
+{
+  Filters::Ptr filters = scope_->filters;
+  WaitForSynchronize(filters, 4);
+
+  MultiRangeFilter::Ptr filter = static_pointer_cast<MultiRangeFilter>(filters->FilterAtIndex(3));
+  EXPECT_EQ(filter->id, "size");
+  EXPECT_EQ(filter->name, "Size");
+  EXPECT_EQ(filter->icon_hint, "");
+  std::string tmp = filter->renderer_name;
+  EXPECT_EQ(filter->renderer_name, "filter-multirange");
+  EXPECT_TRUE(filter->visible);
+  EXPECT_TRUE(filter->collapsed);
+  EXPECT_FALSE(filter->filtering);
+
+  MultiRangeFilter::Options options = filter->options;
+  EXPECT_EQ(options.size(), (unsigned int)4);
+  
+  EXPECT_EQ(options[0]->id, "1MB");
+  EXPECT_EQ(options[0]->name, "1MB");
+  EXPECT_EQ(options[0]->icon_hint, "");
+  EXPECT_FALSE(options[0]->active);
+
+  EXPECT_EQ(options[1]->id, "10MB");
+  EXPECT_EQ(options[1]->name, "10MB");
+  EXPECT_EQ(options[1]->icon_hint, "");
+  EXPECT_FALSE(options[1]->active);
+
+  EXPECT_EQ(options[2]->id, "100MB");
+  EXPECT_EQ(options[2]->name, "100MB");
+  EXPECT_EQ(options[2]->icon_hint, "");
+  EXPECT_FALSE(options[2]->active);
+}
+
+TEST_F(TestScopeFilter, TestFilterMultiRangeLogic)
+{
+  Filters::Ptr filters = scope_->filters;
+  WaitForSynchronize(filters, 4);
+
+  MultiRangeFilter::Ptr filter = static_pointer_cast<MultiRangeFilter>(filters->FilterAtIndex(3));
+  MultiRangeFilter::Options options = filter->options;
+
+  EXPECT_FALSE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+  EXPECT_FALSE (options[3]->active);
+
+  options[0]->active = true;
+  EXPECT_TRUE (options[0]->active);
+  EXPECT_TRUE (filter->filtering);
+  options[3]->active = true;
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_TRUE (options[3]->active);
+
+  options[0]->active = true;
+  options[1]->active = true;
+  EXPECT_TRUE (filter->filtering);
+  EXPECT_TRUE (options[0]->active);
+  EXPECT_TRUE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+  EXPECT_FALSE (options[3]->active);
+
+  options[0]->active = false;
+  EXPECT_TRUE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_TRUE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+  EXPECT_FALSE (options[3]->active);
+
+  filter->Clear();
+  EXPECT_FALSE (filter->filtering);
+  EXPECT_FALSE (options[0]->active);
+  EXPECT_FALSE (options[1]->active);
+  EXPECT_FALSE (options[2]->active);
+  EXPECT_FALSE (options[3]->active);
+}
+
+}
+}

=== added file 'tests/test_scope_impl.c'
--- tests/test_scope_impl.c	1970-01-01 00:00:00 +0000
+++ tests/test_scope_impl.c	2013-03-21 14:03:22 +0000
@@ -0,0 +1,511 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+ 
+#include "test_scope_impl.h"
+#include <unity.h>
+
+#include <stdio.h>
+
+#define TEST_DBUS_NAME "com.canonical.Unity.Test.Scope"
+
+#define _g_object_unref_safe(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
+#define _g_free_safe(var) (var = (g_free (var), NULL))
+
+/* ------------------ Test Searcher ---------------------- */
+
+#define TEST_TYPE_SEARCHER (test_searcher_get_type ())
+#define TEST_SCOPE_SEARCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_SEARCHER, TestSearcher))
+#define TEST_SEARCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_SEARCHER, TestSearcherClass))
+#define TEST_IS_SEARCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_SEARCHER))
+#define TEST_IS_SEARCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_SEARCHER))
+#define TEST_SEARCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_SEARCHER, TestSearcherClass))
+
+typedef struct _TestSearcher TestSearcher;
+typedef struct _TestSearcherClass TestSearcherClass;
+typedef struct _TestSearcherPrivate TestSearcherPrivate;
+
+struct _TestSearcher {
+  UnityScopeSearchBase parent_instance;
+  TestSearcherPrivate * priv;
+};
+
+struct _TestSearcherClass {
+  UnityScopeSearchBaseClass parent_class;
+};
+
+struct _TestSearcherPrivate {
+  TestScope* _owner;
+};
+
+typedef struct _SearcherRunData SearcherRunData;
+
+G_DEFINE_TYPE(TestSearcher, test_searcher, UNITY_TYPE_SCOPE_SEARCH_BASE);
+
+#define TEST_SEARCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_SEARCHER, TestSearcherPrivate))
+enum  {
+  TEST_SEARCHER_DUMMY_PROPERTY,
+  TEST_SEARCHER_OWNER
+};
+
+static TestSearcher* test_searcher_new (TestScope* scope);
+static void test_searcher_run_async (UnityScopeSearchBase* self, UnityScopeSearchBaseCallback async_callback, void* async_callback_target);
+static void test_searcher_run (UnityScopeSearchBase* base);
+static TestScope* test_searcher_get_owner (TestSearcher* self);
+static void test_searcher_set_owner (TestSearcher* self, TestScope* value);
+static void test_searcher_finalize (GObject* obj);
+static void test_searcher_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
+static void test_searcher_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
+
+static TestSearcher* test_searcher_new (TestScope* scope)
+{
+  return (TestSearcher*) g_object_new (TEST_TYPE_SEARCHER, "owner", scope, NULL);
+}
+
+static TestScope* test_searcher_get_owner (TestSearcher* self)
+{
+  g_return_val_if_fail (self != NULL, NULL);
+  return self->priv->_owner;
+}
+
+static void test_searcher_set_owner (TestSearcher* self, TestScope* value)
+{
+  g_return_if_fail (self != NULL);
+  self->priv->_owner = value;
+  g_object_notify ((GObject *) self, "owner");
+}
+
+static void test_searcher_class_init (TestSearcherClass * klass) 
+{
+  g_type_class_add_private (klass, sizeof (TestSearcherPrivate));
+  UNITY_SCOPE_SEARCH_BASE_CLASS (klass)->run_async = test_searcher_run_async;
+  UNITY_SCOPE_SEARCH_BASE_CLASS (klass)->run = test_searcher_run;
+  G_OBJECT_CLASS (klass)->get_property = test_searcher_get_property;
+  G_OBJECT_CLASS (klass)->set_property = test_searcher_set_property;
+  G_OBJECT_CLASS (klass)->finalize = test_searcher_finalize;
+  g_object_class_install_property (G_OBJECT_CLASS (klass), TEST_SEARCHER_OWNER, g_param_spec_object ("owner", "owner", "owner", TEST_TYPE_SCOPE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
+}
+
+static void test_searcher_init(TestSearcher* self)
+{
+  self->priv = TEST_SEARCHER_GET_PRIVATE (self);
+}
+
+static void test_searcher_finalize (GObject* obj)
+{
+  TestSearcher * self;
+  self = TEST_SCOPE_SEARCHER (obj);
+  G_OBJECT_CLASS (test_searcher_parent_class)->finalize (obj);
+}
+
+static void test_searcher_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec)
+{
+  TestSearcher * self;
+  self = TEST_SCOPE_SEARCHER (object);
+  switch (property_id) {
+    case TEST_SEARCHER_OWNER:
+    g_value_set_object (value, test_searcher_get_owner (self));
+    break;
+    default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    break;
+  }
+}
+
+static void test_searcher_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec)
+{
+  TestSearcher * self;
+  self = TEST_SCOPE_SEARCHER (object);
+  switch (property_id) {
+    case TEST_SEARCHER_OWNER:
+    test_searcher_set_owner (self, g_value_get_object (value));
+    break;
+    default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    break;
+  }
+}
+
+struct _SearcherRunData 
+{
+  int _ref_count_;
+  TestSearcher * self;
+  GMainLoop* ml;
+  UnityScopeSearchBaseCallback async_callback;
+  void* async_callback_target;
+};
+
+static SearcherRunData* run_data_ref (SearcherRunData* data)
+{
+  g_atomic_int_inc (&data->_ref_count_);
+  return data;
+}
+
+static void run_data_unref (void * _userdata_)
+{
+  SearcherRunData* data;
+  data = (SearcherRunData*) _userdata_;
+  if (g_atomic_int_dec_and_test (&data->_ref_count_))
+  {
+    TestSearcher* self;
+    self = data->self;
+    g_main_loop_unref (data->ml);
+    g_object_unref (self);
+    g_slice_free (SearcherRunData, data);
+  }
+}
+
+static gboolean test_searcher_main_loop_func (gpointer data)
+{
+  SearcherRunData* search_data;
+  search_data = (SearcherRunData*) data;
+
+  TestSearcher* self;
+  self = search_data->self;
+  UNITY_SCOPE_SEARCH_BASE_GET_CLASS (self)->run(UNITY_SCOPE_SEARCH_BASE (self));
+
+  search_data->async_callback (UNITY_SCOPE_SEARCH_BASE (self), search_data->async_callback_target);
+  g_main_loop_quit (search_data->ml);
+  return FALSE;
+}
+
+static void test_searcher_run_async (UnityScopeSearchBase* base, UnityScopeSearchBaseCallback async_callback, void* async_callback_target)
+{
+  TestSearcher * self;
+  SearcherRunData* data;
+  self = TEST_SCOPE_SEARCHER (base);
+  data = g_slice_new (SearcherRunData);
+  data->_ref_count_ = 1;
+  data->self = g_object_ref (self);
+  data->ml = g_main_loop_new (NULL, FALSE);
+  data->async_callback = async_callback;
+  data->async_callback_target = async_callback_target;
+
+  g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, test_searcher_main_loop_func, run_data_ref (data), run_data_unref);
+  g_main_loop_run (data->ml);
+  run_data_unref (data);
+  data = NULL;
+}
+
+static void test_searcher_run (UnityScopeSearchBase* base)
+{
+  TestSearcher* self;
+  self = TEST_SCOPE_SEARCHER (base);
+
+  g_signal_emit_by_name (self->priv->_owner, "search", base);
+}
+
+/* ------------------ Test Result Previewer ---------------------- */
+
+#define TEST_TYPE_RESULT_PREVIEWER (test_result_previewer_get_type ())
+#define TEST_RESULT_PREVIEWER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_RESULT_PREVIEWER, TestResultPreviewer))
+#define TEST_RESULT_PREVIEWER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_RESULT_PREVIEWER, TestResultPreviewerClass))
+#define TEST_IS_RESULT_PREVIEWER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_RESULT_PREVIEWER))
+#define TEST_IS_RESULT_PREVIEWER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_RESULT_PREVIEWER))
+#define TEST_RESULT_PREVIEWER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_RESULT_PREVIEWER, TestResultPreviewerClass))
+
+typedef struct _TestResultPreviewer TestResultPreviewer;
+typedef struct _TestResultPreviewerClass TestResultPreviewerClass;
+
+struct _TestResultPreviewer {
+  UnityResultPreviewer parent_instance;
+};
+
+struct _TestResultPreviewerClass {
+  UnityResultPreviewerClass parent_class;
+};
+
+G_DEFINE_TYPE(TestResultPreviewer, test_result_previewer, UNITY_TYPE_RESULT_PREVIEWER);
+
+static UnityAbstractPreview* test_result_previewer_run(UnityResultPreviewer* self)
+{
+  UnityAbstractPreview* preview;
+  preview = UNITY_ABSTRACT_PREVIEW (unity_generic_preview_new ("title", "description", NULL));
+
+  unity_preview_add_action(UNITY_PREVIEW (preview), unity_preview_action_new ("action1", "Action 1", NULL));
+  unity_preview_add_action(UNITY_PREVIEW (preview), unity_preview_action_new ("action2", "Action 2", NULL));
+
+  return preview;
+}
+
+static void test_result_previewer_class_init(TestResultPreviewerClass* klass)
+{
+  UNITY_RESULT_PREVIEWER_CLASS (klass)->run = test_result_previewer_run;
+}
+
+static void test_result_previewer_init(TestResultPreviewer* self)
+{
+}
+
+TestResultPreviewer* test_result_previewer_new ()
+{
+  return (TestResultPreviewer*) g_object_new (TEST_TYPE_RESULT_PREVIEWER, NULL);
+}
+
+/* ------------------ Test Scope ---------------------- */
+
+#define TEST_SCOPE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_SCOPE, TestScopePrivate))
+
+G_DEFINE_TYPE(TestScope, test_scope, UNITY_TYPE_ABSTRACT_SCOPE);
+
+struct _TestScopePrivate
+{
+  gchar* _dbus_path;
+  UnityScopeDBusConnector* _connector;
+  UnityCategorySet* _categories;
+  UnityFilterSet* _filters;
+};
+
+enum  {
+  TEST_SCOPE_DUMMY_PROPERTY,
+  TEST_SCOPE_DBUS_PATH
+};
+
+static UnityScopeSearchBase* test_scope_create_search_for_query(UnityAbstractScope* self, UnitySearchContext* search_context);
+static UnityResultPreviewer* test_scope_create_previewer(UnityAbstractScope* self, UnityScopeResult* _result_, UnitySearchMetadata* metadata);
+static UnityCategorySet* test_scope_get_categories(UnityAbstractScope* self);
+static UnityFilterSet* test_scope_get_filters(UnityAbstractScope* self);
+static UnitySchema* test_scope_get_schema(UnityAbstractScope* self);
+static gchar* test_scope_get_search_hint(UnityAbstractScope* self);
+static gchar* test_scope_get_group_name(UnityAbstractScope* self);
+static gchar* test_scope_get_unique_name(UnityAbstractScope* self);
+static UnityActivationResponse* test_scope_activate(UnityAbstractScope* self, UnityScopeResult* _result_, UnitySearchMetadata* metadata, const gchar* action_id);
+static void test_scope_set_dbus_path (TestScope* self, const gchar* value);
+static const gchar* test_scope_get_dbus_path (TestScope* self);
+
+static void test_scope_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
+static void test_scope_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
+static void g_cclosure_user_marshal_OBJECT__STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
+
+static void test_scope_class_init(TestScopeClass* klass)
+{
+  g_type_class_add_private (klass, sizeof (TestScopePrivate));
+
+  UNITY_ABSTRACT_SCOPE_CLASS (klass)->create_search_for_query = test_scope_create_search_for_query;
+  UNITY_ABSTRACT_SCOPE_CLASS (klass)->create_previewer = test_scope_create_previewer;
+  UNITY_ABSTRACT_SCOPE_CLASS (klass)->get_categories = test_scope_get_categories;
+  UNITY_ABSTRACT_SCOPE_CLASS (klass)->get_filters = test_scope_get_filters;
+  UNITY_ABSTRACT_SCOPE_CLASS (klass)->get_schema = test_scope_get_schema;
+  UNITY_ABSTRACT_SCOPE_CLASS (klass)->get_search_hint = test_scope_get_search_hint;
+  UNITY_ABSTRACT_SCOPE_CLASS (klass)->get_group_name = test_scope_get_group_name;
+  UNITY_ABSTRACT_SCOPE_CLASS (klass)->get_unique_name = test_scope_get_unique_name;
+  UNITY_ABSTRACT_SCOPE_CLASS (klass)->activate = test_scope_activate;
+  G_OBJECT_CLASS (klass)->get_property = test_scope_get_property;
+  G_OBJECT_CLASS (klass)->set_property = test_scope_set_property;
+
+  g_object_class_install_property (G_OBJECT_CLASS (klass), TEST_SCOPE_DBUS_PATH, g_param_spec_string ("dbus-path", "dbus-path", "dbus-path", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
+  g_signal_new ("search", TEST_TYPE_SCOPE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, UNITY_TYPE_SCOPE_SEARCH_BASE);
+  g_signal_new ("activate_uri", TEST_TYPE_SCOPE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_OBJECT__STRING, UNITY_TYPE_ACTIVATION_RESPONSE, 1, G_TYPE_STRING);
+}
+
+static void test_scope_init(TestScope* self)
+{
+  self->priv = TEST_SCOPE_GET_PRIVATE (self);
+
+  self->priv->_dbus_path = NULL;
+  self->priv->_connector = NULL;
+  self->priv->_categories = NULL;
+  self->priv->_filters = NULL;
+}
+
+static void test_scope_finalize (GObject* obj)
+{
+  TestScope * self;
+  self = G_TYPE_CHECK_INSTANCE_CAST (obj, TEST_TYPE_SCOPE, TestScope);
+  _g_free_safe (self->priv->_dbus_path);
+  _g_object_unref_safe (self->priv->_connector);
+  _g_object_unref_safe (self->priv->_categories);
+  G_OBJECT_CLASS (test_scope_parent_class)->finalize (obj);
+}
+
+static void test_scope_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec)
+{
+  TestScope * self;
+  self = G_TYPE_CHECK_INSTANCE_CAST (object, TEST_TYPE_SCOPE, TestScope);
+  switch (property_id)
+  {
+    case TEST_SCOPE_DBUS_PATH:
+    g_value_set_string (value, test_scope_get_dbus_path (self));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    break;
+  }
+}
+
+static void test_scope_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec)
+{
+  TestScope * self;
+  self = G_TYPE_CHECK_INSTANCE_CAST (object, TEST_TYPE_SCOPE, TestScope);
+  switch (property_id) {
+    case TEST_SCOPE_DBUS_PATH:
+    test_scope_set_dbus_path (self, g_value_get_string (value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    break;
+  }
+}
+
+static UnityScopeSearchBase* test_scope_create_search_for_query(UnityAbstractScope* base, UnitySearchContext* search_context)
+{
+  UnityScopeSearchBase* searcher;
+  TestScope* scope;
+  scope = (TestScope*) base;
+  searcher = (UnityScopeSearchBase*) test_searcher_new (scope);
+
+  UnitySearchContext ctx;
+  ctx = *search_context;
+  unity_scope_search_base_set_search_context (searcher, &ctx);
+  return searcher;
+}
+
+static UnityResultPreviewer* test_scope_create_previewer(UnityAbstractScope* self, UnityScopeResult* result, UnitySearchMetadata* metadata)
+{
+  UnityResultPreviewer* previewer;
+  previewer = UNITY_RESULT_PREVIEWER (test_result_previewer_new());
+  unity_scope_result_copy(result, &previewer->result);
+  return previewer;
+}
+
+static UnityCategorySet* test_scope_get_categories(UnityAbstractScope* base)
+{
+  TestScope* self;
+  self = G_TYPE_CHECK_INSTANCE_CAST (base, TEST_TYPE_SCOPE, TestScope);
+  g_return_if_fail (self != NULL);
+
+  return self->priv->_categories;
+}
+
+static UnityFilterSet* test_scope_get_filters(UnityAbstractScope* base)
+{
+  TestScope* self;
+  self = G_TYPE_CHECK_INSTANCE_CAST (base, TEST_TYPE_SCOPE, TestScope);
+  g_return_if_fail (self != NULL);
+
+  return self->priv->_filters;
+}
+
+static UnitySchema* test_scope_get_schema(UnityAbstractScope* self)
+{
+  UnitySchema* schema = unity_schema_new ();
+  unity_schema_add_field (schema, "required_string", "s", UNITY_SCHEMA_FIELD_TYPE_REQUIRED);
+  unity_schema_add_field (schema, "required_int", "i", UNITY_SCHEMA_FIELD_TYPE_REQUIRED);
+  unity_schema_add_field (schema, "optional_string", "s", UNITY_SCHEMA_FIELD_TYPE_OPTIONAL);
+  return schema;
+}
+
+static gchar* test_scope_get_search_hint(UnityAbstractScope* self)
+{