Merge lp:~michihenning/unity-scopes-api/cache-results into lp:unity-scopes-api

[Michi Henning]

Added result cache that stores the results of the last successful surfacing query. The scope, if it detects connectivity problems, can call reply->push_surfacing_results_from_cache(). This answers the query from the cache, provided that the query is indeed a surfacing query. Otherwise, the method does nothing.

Note: This is change is ABI compatible with gcc and clang despite the addition of a new virtual function.

Added result cache that stores the results of the last successful surfacing query. The scope, if it detects connectivity problems, can call reply->push_surfacing_results_from_cache(). This answers the query from the cache, provided that the query is indeed a surfacing query. Otherwise, the method does nothing.

Note: This is change is ABI compatible with gcc and clang despite the addition of a new virtual function.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:572
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~michihenning/unity-scopes-api/cache-results/+merge/246257/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/unity-scopes-api-ci/505/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-amd64-ci/30/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/30/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-i386-ci/30/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-ci/505/rebuild

review: Needs Fixing (continuous-integration)

[Michi Henning (michihenning)]

Re-submitting a proposal causes launchpad to nuke the commit message. Neat…

[Michi Henning (michihenning)]

Marking this as work in progress until we get the go-ahead for an ABI-breaking change.

[Michi Henning (michihenning)]

I've checked that this doesn't break anything when we substitute the new library underneath code that was compiled against the previous version, so I'm putting this back up for review.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:575
http://jenkins.qa.ubuntu.com/job/unity-scopes-api-ci/513/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-amd64-ci/38
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/38
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/38/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-i386-ci/38

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-ci/513/rebuild

review: Approve (continuous-integration)

[lp:~michihenning/unity-scopes-api/cache-results]

576. By Michi Henning on 2015-01-20

Merged trunk and resolved conflicts.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:576
http://jenkins.qa.ubuntu.com/job/unity-scopes-api-ci/531/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-amd64-ci/56/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/56
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/56/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-i386-ci/56

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-ci/531/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:576
http://jenkins.qa.ubuntu.com/job/unity-scopes-api-ci/532/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-amd64-ci/58/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/57
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/57/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-i386-ci/57

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-ci/532/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:576
http://jenkins.qa.ubuntu.com/job/unity-scopes-api-ci/535/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-amd64-ci/62
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/60
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/60/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-i386-ci/60

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-ci/535/rebuild

review: Approve (continuous-integration)

[Paweł Stołowski (stolowski)]

279 + std::vector<CatPair> categories_; // vector instead of map, so we preserve order

Hmm, we do call lookup_category *a lot* internally (practically for every result), so I'm a little bit worried about the additional cpu cycles with linear search, especially in aggregation scenarios. Two cases where we call it:

1) CategorisedResultImpl::CategorisedResultImpl(internal::CategoryRegistry const& reg, VariantMap const& variant_map)

and:

2) bool SearchReplyImpl::push(unity::scopes::CategorisedResult const& result)
{
    // If this is an aggregator scope, it may be pushing result items obtained
    // from ReplyObject without registering a category first.
    if (cat_registry_->lookup_category(result.category()->id()) == nullptr)
    {
        register_category(result.category());

(I don't remember from top of my head why we do it in 1st case, but the 2nd one has a good comment explaining it).

Is it really important to preserve the order of categories, given that the order of results determines actual order? If so, perhaps it would make sense to keep a map aside for faster lookups?

review: Needs Information

[Paweł Stołowski (stolowski)]

> 1) CategorisedResultImpl::CategorisedResultImpl(internal::CategoryRegistry
> const& reg, VariantMap const& variant_map)
>
> and:
>
> 2) bool SearchReplyImpl::push(unity::scopes::CategorisedResult const& result)
> {
> // If this is an aggregator scope, it may be pushing result items obtained
> // from ReplyObject without registering a category first.
> if (cat_registry_->lookup_category(result.category()->id()) == nullptr)
> {
> register_category(result.category());
>
> (I don't remember from top of my head why we do it in 1st case, but the 2nd
> one has a good comment explaining it).

Ah, now I remember, the 1st case is when we deserialize incoming results and need category pointers.

[Paweł Stołowski (stolowski)]

824 + VariantMap dict = r.get_dict();
825 + string const cat_id = dict.at("internal").get_dict().at("cat_id").get_string();
826 + auto cat = lookup_category(cat_id);
827 + auto crip = new CategorisedResultImpl(move(cat), move(dict));
828 + auto cr = CategorisedResult(crip);

I think this could be simplified by constructing CategorisedResult using this ctor:
CategorisedResultImpl::CategorisedResultImpl(internal::CategoryRegistry const& reg, VariantMap const& variant_map)

[Paweł Stołowski (stolowski)]

Hmm, I think this will need to be extended to support filters (we only realistically need to support option selector filter atm, but if you use FilterBaseImpl::deserialize_filters / serialize_filters, it will work for all of them with no extra work).

Other than the above this looks really cool, I like it a lot!

review: Needs Fixing

[Michi Henning (michihenning)]

> Hmm, we do call lookup_category *a lot* internally (practically for every
> result), so I'm a little bit worried about the additional cpu cycles with
> linear search, especially in aggregation scenarios. Two cases where we call
> it:
>
> 1) CategorisedResultImpl::CategorisedResultImpl(internal::CategoryRegistry
> const& reg, VariantMap const& variant_map)
>
> and:
>
> 2) bool SearchReplyImpl::push(unity::scopes::CategorisedResult const& result)
> {
> // If this is an aggregator scope, it may be pushing result items obtained
> // from ReplyObject without registering a category first.
> if (cat_registry_->lookup_category(result.category()->id()) == nullptr)
> {
> register_category(result.category());
>
> (I don't remember from top of my head why we do it in 1st case, but the 2nd
> one has a good comment explaining it).
>
> Is it really important to preserve the order of categories, given that the
> order of results determines actual order? If so, perhaps it would make sense
> to keep a map aside for faster lookups?

Well... Even assuming that linear search will be slower, it doesn't matter. We are going on the wire for each of these calls. The cost of finding the category is minuscule compared to pushing a result.

But, secondly, linear search will almost certainly *not* be slower. A vector will be faster than a map unless there are at least several thousand elements. That's because the elements of a vector are contiguous in memory, so vector plays very nicely with the CPU caches. In contrast, pretty much every node in a map will be at a completely different memory location, meaning that on every step of the lookup, we get a cache miss and do a trip to main memory (which is around 1000 times slower than a cache hit).

The old adage about O(log n) being preferable is true only if n is large and if we assume that all data accesses have equal cost. With a cache miss adding a constant factor of around 1000, O(n) with a constant factor of 1 is miles faster because our n is small.

But, anyway, for our performance requirements, it truly doesn't matter. Either would be plenty fast enough :-) I used a vector simply because I needed to preserve order, not because of performance concerns.

[Michi Henning (michihenning)]

> I think this could be simplified by constructing CategorisedResult using this
> ctor:
> CategorisedResultImpl::CategorisedResultImpl(internal::CategoryRegistry const&
> reg, VariantMap const& variant_map)

Fixed, thanks for that!

[Michi Henning (michihenning)]

> Hmm, I think this will need to be extended to support filters (we only
> realistically need to support option selector filter atm, but if you use
> FilterBaseImpl::deserialize_filters / serialize_filters, it will work for all
> of them with no extra work).

Caching applies only to surfacing queries. I thought that these can never have a filter?

[lp:~michihenning/unity-scopes-api/cache-results]

577. By Michi Henning on 2015-02-04

Merged trunk.

578. By Michi Henning on 2015-02-04

Simplified CategorisedResult instantiation when pushing from cache.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:573
http://jenkins.qa.ubuntu.com/job/unity-scopes-api-ci/562/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-amd64-ci/89
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/87
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/87/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-i386-ci/88

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-ci/562/rebuild

review: Approve (continuous-integration)

[Paweł Stołowski (stolowski)]

> But, anyway, for our performance requirements, it truly doesn't matter. Either
> would be plenty fast enough :-) I used a vector simply because I needed to
> preserve order, not because of performance concerns.

Fair enough, I think you're right :)

[Paweł Stołowski (stolowski)]

> > Hmm, I think this will need to be extended to support filters (we only
> > realistically need to support option selector filter atm, but if you use
> > FilterBaseImpl::deserialize_filters / serialize_filters, it will work for
> all
> > of them with no extra work).
>
> Caching applies only to surfacing queries. I thought that these can never have
> a filter?

I don't think we should be making this assumption. Nothing stops scope author from pushing departments and an additional navigation menu (single-selection filter) atm.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:578
http://jenkins.qa.ubuntu.com/job/unity-scopes-api-ci/563/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-amd64-ci/90
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/88
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/88/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-i386-ci/89

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-ci/563/rebuild

review: Approve (continuous-integration)

[lp:~michihenning/unity-scopes-api/cache-results]

579. By Michi Henning on 2015-02-05

Added filters and filter_state to cached results and added corresponding tests.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:579
http://jenkins.qa.ubuntu.com/job/unity-scopes-api-ci/565/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-amd64-ci/92
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/90
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-armhf-ci/90/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-vivid-i386-ci/91

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-ci/565/rebuild

review: Approve (continuous-integration)

[Paweł Stołowski (stolowski)]

Great, thank you!

review: Approve

[Paweł Stołowski (stolowski)]

> Note: This is change is ABI compatible with gcc and clang despite the addition of a new virtual function.

I'll never ever believe you when you say that ;) [details in the email]

review: Needs Fixing

[Michi Henning (michihenning)]

After discussing with Thomas, I'm rejecting this MR for the time being. This is just too bloody dangerous. It's better not to have the feature than having the uncertainty of random scopes getting core dumps.

review: Disapprove

[lp:~michihenning/unity-scopes-api/cache-results]

580. By Michi Henning on 2015-02-12

Moved push_surfacing_results_from_cache to end of virtual functions to
avoid ABI break.

[Paweł Stołowski (stolowski)]

Michi, could you please merge trunk?

review: Needs Fixing

[lp:~michihenning/unity-scopes-api/cache-results]

581. By Michi Henning on 2015-02-12

Merged trunk and resolved conflicts.

[Michi Henning (michihenning)]

> Michi, could you please merge trunk?

Done.

[Paweł Stołowski (stolowski)]

Michi, you need to bump micro version again (we are already at 0.6.13) and update changelog and release notes.

[lp:~michihenning/unity-scopes-api/cache-results]

582. By Michi Henning on 2015-02-13

Update micro version, changelog, and release notes.

[Michi Henning (michihenning)]

Thanks for the heads-up, and my apologies for that! This branch is getting kind of long in the tooth, seeing that I first pushed it a month ago. Oh, the world is marching on around me ;-)

[lp:~michihenning/unity-scopes-api/cache-results]

583. By Michi Henning on 2015-02-13

Fixed changelog. (Thanks Pawel!)

=== modified file 'RELEASE_NOTES.md'
--- RELEASE_NOTES.md	2015-01-28 09:06:08 +0000
+++ RELEASE_NOTES.md	2015-02-05 09:36:37 +0000
@@ -16,6 +16,15 @@
 
 Changes in version 0.6.11
 =========================
+  - Added push_surfacing_results_from_cache() to Reply proxy. This allows a scope
+    to reply the results of the last succesful surfacing query from an on-disk cache.
+    This is useful to prevent the user being presented with an empty screen when
+    swiping to the scope while the device has no network access, or the scope's
+    data source is off-line.
+
+    Note: This is change is ABI compatible with gcc and clang despite the addition 
+          a new virtual function.
+
   - The JSON for a CategoryRenderer now supports a "fallback" field in the
     "art" and "mascot" entries of the "components" dictionary.
     This allows a scope to specify a category-specific

=== modified file 'debian/changelog'
--- debian/changelog	2015-01-30 12:34:42 +0000
+++ debian/changelog	2015-02-05 09:36:37 +0000
@@ -95,6 +95,20 @@
 
  -- Ubuntu daily release <[e-mail]>  Mon, 19 Jan 2015 08:09:11 +0000
 
+unity-scopes-api (0.6.11+15.04) UNRELEASED; urgency=medium
+
+  [ Michi Henning ]
+  * Added push_surfacing_results_from_cache() to Reply proxy. This allows a scope
+    to reply the results of the last succesful surfacing query from an on-disk cache.
+    This is useful to prevent the user being presented with an empty screen when
+    swiping to the scope while the device has no network access, or the scope's
+    data source is off-line.
+
+    Note: This is change is ABI compatible with gcc and clang despite the addition 
+          a new virtual function.
+
+ -- Michi Henning <[e-mail]>  Thu, 15 Jan 2015 14:22:17 +1000
+
 unity-scopes-api (0.6.11-0ubuntu1) UNRELEASED; urgency=medium
 
   * Improved logging internals.

=== modified file 'debian/libunity-scopes3.symbols'
--- debian/libunity-scopes3.symbols	2015-01-30 12:34:39 +0000
+++ debian/libunity-scopes3.symbols	2015-02-05 09:36:37 +0000
@@ -423,6 +423,7 @@
  (c++)"unity::scopes::internal::RuntimeConfig::ss_registry_identity() const@Base" 0.4.4+14.10.20140508
  (c++)"unity::scopes::internal::RuntimeConfig::trace_channels() const@Base" 0.6.11+15.04.20150119
  (c++)"unity::scopes::internal::RuntimeImpl::async_pool() const@Base" 0.4.3+14.10.20140428
+ (c++)"unity::scopes::internal::RuntimeImpl::cache_directory() const@Base" 0replaceme
  (c++)"unity::scopes::internal::RuntimeImpl::confined() const@Base" 0.6.8+15.04.20141119
  (c++)"unity::scopes::internal::RuntimeImpl::confinement_type() const@Base" 0.6.8+15.04.20141119
  (c++)"unity::scopes::internal::RuntimeImpl::create(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.4.0+14.04.20140312.1
@@ -448,6 +449,7 @@
  (c++)"unity::scopes::internal::RuntimeImpl::ss_configfile() const@Base" 0.4.4+14.10.20140508
  (c++)"unity::scopes::internal::RuntimeImpl::ss_registry_identity() const@Base" 0.4.4+14.10.20140508
  (c++)"unity::scopes::internal::RuntimeImpl::string_to_proxy(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const@Base" 0.4.0+14.04.20140312.1
+ (c++)"unity::scopes::internal::RuntimeImpl::tmp_directory() const@Base" 0replaceme
  (c++)"unity::scopes::internal::RuntimeImpl::waiter_thread(std::shared_ptr<unity::scopes::internal::ThreadSafeQueue<std::future<void> > > const&) const@Base" 0.4.3+14.10.20140428
  (c++)"unity::scopes::internal::safe_strerror(int)@Base" 0.6.9+15.04.20141129
  (c++)"unity::scopes::internal::ScopeConfig::appearance_attributes() const@Base" 0.4.2+14.04.20140404.2

=== modified file 'doc/tutorial.dox'
--- doc/tutorial.dox	2015-01-06 06:08:09 +0000
+++ doc/tutorial.dox	2015-02-05 09:36:37 +0000
@@ -229,6 +229,19 @@
 here (if at all possible), so the user gets to see at least some results (instead of being confronted with
 a blank screen).
 
+The runtime automatically saves the results of the most recent surfacing query. If a scope cannot produce
+a result for a surfacing query (presumably, due to connectivity problems), calling
+\link unity::scopes::SearchReply::push_surfacing_results_from_cache() push_surfacing_results_from_cache()\endlink
+pushes the results that were produced by the most recent successful
+surfacing query from the cache. If your scope cannot produce surfacing results, you can call this
+method to "replay" the results of the previous surfacing query. In turn, this avoids the user
+being presented with an empty screen if he/she swipes to the scope while the device does not have connectivity.
+
+`push_surfacing_results_from_cache()` has an effect only if called for a surfacing query (that is, a query with an empty query string). If called for a non-empty query, it does nothing.
+
+You must call this method before calling \link unity::scopes::Reply::finished finished()\endlink,
+otherwise no cached results will be pushed. (`push_surfacing_results_from_cache() implicitly calls `finished()`);
+
 \paragraph querybase Implementing QueryBase
 
 You must implement a class that derives from \link unity::scopes::SearchQueryBase SearchQueryBase\endlink and return

=== modified file 'include/unity/scopes/CategorisedResult.h'
--- include/unity/scopes/CategorisedResult.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/CategorisedResult.h	2015-02-05 09:36:37 +0000
@@ -31,6 +31,7 @@
 {
     class CategorisedResultImpl;
     class ResultReplyObject;
+    class SearchReplyImpl;
 }
 
 /**
@@ -80,6 +81,7 @@
 
     friend class internal::CategorisedResultImpl;
     friend class internal::ResultReplyObject;
+    friend class internal::SearchReplyImpl;
 };
 
 } // namespace scopes

=== modified file 'include/unity/scopes/Category.h'
--- include/unity/scopes/Category.h	2015-01-26 08:20:45 +0000
+++ include/unity/scopes/Category.h	2015-02-05 09:36:37 +0000
@@ -36,6 +36,7 @@
 {
     class CategoryImpl;
     class CategoryRegistry;
+    class SearchReplyImpl;
 }
 
 /**
@@ -100,6 +101,7 @@
     /// @endcond
 
     friend class internal::CategoryRegistry;
+    friend class internal::SearchReplyImpl;
 
 private:
     std::unique_ptr<internal::CategoryImpl> p;

=== modified file 'include/unity/scopes/SearchReply.h'
--- include/unity/scopes/SearchReply.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/SearchReply.h	2015-02-05 09:36:37 +0000
@@ -141,6 +141,27 @@
     virtual bool push(Filters const& filters, FilterState const& filter_state) = 0;
 
     /**
+    \brief Push the results that were produced by the most recent surfacing query.
+
+    The runtime automatically saves the results of the most recent surfacing query.
+    If a scope cannot produce a result for a surfacing query (presumably, due to
+    connectivity problems), calling push_surfacing_results_from_cache() pushes
+    the results that were produced by the most recent successful surfacing query
+    from the cache. If a scope cannot produce surfacing results, it can call this
+    method to "replay" the previous results. In turn, this avoids the user being
+    presented with an empty screen if he/she swipes to the scope while the device
+    does not have connectivity.
+
+    This method has an effect only if called for a surfacing query (that is, a
+    query with an empty query string). If called for a non-empty query, it does
+    nothing.
+
+    You must call this method before calling finished(), otherwise no cached results
+    will be pushed (push_surfacing_results_from_cache() implicitly calls finished()).
+    */
+    virtual void push_surfacing_results_from_cache() = 0;
+
+    /**
     \brief Destroys a Reply.
 
     If a Reply goes out of scope without a prior call to finished(), the destructor implicitly calls finished().

=== added file 'include/unity/scopes/internal/''
--- include/unity/scopes/internal/'	1970-01-01 00:00:00 +0000
+++ include/unity/scopes/internal/'	2015-02-05 09:36:37 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/scopes/internal/MWRegistryProxyFwd.h>
+#include <unity/scopes/internal/ObjectImpl.h>
+#include <unity/scopes/Registry.h>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class RegistryImpl : public virtual unity::scopes::Registry, public virtual ObjectImpl
+{
+public:
+    RegistryImpl(MWRegistryProxy const& mw_proxy);
+    ~RegistryImpl();
+
+    virtual ScopeMetadata get_metadata(std::string const& scope_id) override;
+    virtual MetadataMap list() override;
+    virtual MetadataMap list_if(std::function<bool(ScopeMetadata const& item)> predicate) override;
+    virtual bool is_scope_running(std::string const& scope_id) override;
+
+    virtual core::ScopedConnection set_scope_state_callback(std::string const& scope_id, std::function<void(bool)> callback) override;
+    virtual core::ScopedConnection set_list_update_callback(std::function<void()> callback) override;
+
+    // Remote operation. Not part of public API, hence not override.
+    ObjectProxy locate(std::string const& identity);
+
+private:
+    MWRegistryProxy fwd();
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace unity

=== modified file 'include/unity/scopes/internal/CategoryRegistry.h'
--- include/unity/scopes/internal/CategoryRegistry.h	2015-01-14 02:19:17 +0000
+++ include/unity/scopes/internal/CategoryRegistry.h	2015-02-05 09:36:37 +0000
@@ -71,9 +71,16 @@
     */
     void register_category(Category::SCPtr category);
 
+    /**
+    \brief Serializes all categories in the registry.
+    \return VariantArray containing all categories.
+    */
+    VariantArray serialize() const;
+
 private:
     mutable std::mutex mutex_;
-    std::map<std::string, Category::SCPtr> categories_;
+    typedef std::pair<std::string, Category::SCPtr> CatPair;
+    std::vector<CatPair> categories_;                         // vector instead of map, so we preserve order
 };
 
 } // namespace internal

=== modified file 'include/unity/scopes/internal/RegistryImpl.h'
--- include/unity/scopes/internal/RegistryImpl.h	2015-01-09 03:16:51 +0000
+++ include/unity/scopes/internal/RegistryImpl.h	2015-02-05 09:36:37 +0000
@@ -31,8 +31,6 @@
 namespace internal
 {
 
-class RuntimeImpl;
-
 class RegistryImpl : public virtual unity::scopes::Registry, public virtual ObjectImpl
 {
 public:

=== modified file 'include/unity/scopes/internal/RuntimeImpl.h'
--- include/unity/scopes/internal/RuntimeImpl.h	2015-01-16 02:59:43 +0000
+++ include/unity/scopes/internal/RuntimeImpl.h	2015-02-05 09:36:37 +0000
@@ -62,6 +62,9 @@
     ObjectProxy string_to_proxy(std::string const& s) const;
     std::string proxy_to_string(ObjectProxy const& proxy) const;
 
+    std::string cache_directory() const;
+    std::string tmp_directory() const;
+
     ~RuntimeImpl();
 
 private:
@@ -91,7 +94,6 @@
     std::string app_dir_;
     std::string log_dir_;
     std::string config_dir_;
-    std::string tmp_dir_;
     Logger::UPtr logger_;
     mutable Reaper::SPtr reply_reaper_;
     mutable ThreadPool::SPtr async_pool_;  // Pool of invocation threads for async query creation

=== modified file 'include/unity/scopes/internal/SearchReplyImpl.h'
--- include/unity/scopes/internal/SearchReplyImpl.h	2015-01-09 03:16:51 +0000
+++ include/unity/scopes/internal/SearchReplyImpl.h	2015-02-05 09:36:37 +0000
@@ -53,6 +53,7 @@
     SearchReplyImpl(MWReplyProxy const& mw_proxy,
                     std::shared_ptr<QueryObjectBase>const & qo,
                     int cardinality,
+                    std::string const& query_string,
                     std::string const& current_department_id);
     virtual ~SearchReplyImpl();
 
@@ -75,14 +76,27 @@
     virtual bool push(unity::scopes::CategorisedResult const& result) override;
     virtual bool push(unity::scopes::Filters const& filters, unity::scopes::FilterState const& filter_state) override;
 
+    virtual void finished() override;
+
+    virtual void push_surfacing_results_from_cache() noexcept;
+
 private:
     bool push(Category::SCPtr category);
+    void write_cached_results() noexcept;
 
     std::shared_ptr<CategoryRegistry> cat_registry_;
 
     std::atomic_int cardinality_;
     std::atomic_int num_pushes_;
+    std::atomic_bool finished_;
+    std::string query_string_;
     std::string current_department_;
+
+    Department::SCPtr cached_departments_;
+    unity::scopes::Filters cached_filters_;
+    unity::scopes::FilterState cached_filter_state_;
+    std::vector<unity::scopes::CategorisedResult> cached_results_;
+    std::mutex mutex_;
 };
 
 } // namespace internal

=== modified file 'include/unity/scopes/testing/MockSearchReply.h'
--- include/unity/scopes/testing/MockSearchReply.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/testing/MockSearchReply.h	2015-02-05 09:36:37 +0000
@@ -65,6 +65,7 @@
     MOCK_METHOD1(push, bool(CategorisedResult const&));
     MOCK_METHOD2(push, bool(Filters const&, FilterState const&));
     MOCK_METHOD1(push, bool(experimental::Annotation const& annotation));
+    MOCK_METHOD0(push_surfacing_results_from_cache, void());
 };
 
 /// @endcond

=== modified file 'include/unity/scopes/utility/internal/BufferedSearchReplyImpl.h'
--- include/unity/scopes/utility/internal/BufferedSearchReplyImpl.h	2014-12-17 01:48:23 +0000
+++ include/unity/scopes/utility/internal/BufferedSearchReplyImpl.h	2015-02-05 09:36:37 +0000
@@ -18,13 +18,14 @@
 
 #pragma once
 
+#include <unity/scopes/CategorisedResult.h>
 #include <unity/scopes/SearchReply.h>
 #include <unity/scopes/SearchReplyProxyFwd.h>
-#include <unity/scopes/CategorisedResult.h>
+
+#include <atomic>
 #include <memory>
+#include <mutex>
 #include <vector>
-#include <mutex>
-#include <atomic>
 
 namespace unity
 {
@@ -62,6 +63,8 @@
     bool push(unity::scopes::CategorisedResult const& result) override;
     bool push(unity::scopes::Filters const& filters, unity::scopes::FilterState const& filter_state) override;
 
+    void push_surfacing_results_from_cache() override;
+
     // Reply interface
     void finished() override;
     void error(std::exception_ptr ex) override;

=== modified file 'src/scopes/internal/CategoryRegistry.cpp'
--- src/scopes/internal/CategoryRegistry.cpp	2014-07-02 09:36:34 +0000
+++ src/scopes/internal/CategoryRegistry.cpp	2015-02-05 09:36:37 +0000
@@ -18,6 +18,8 @@
 
 #include <unity/scopes/internal/CategoryRegistry.h>
 #include <unity/UnityExceptions.h>
+
+#include <algorithm>
 #include <sstream>
 
 namespace unity
@@ -32,13 +34,13 @@
 void CategoryRegistry::register_category(Category::SCPtr category)
 {
     std::lock_guard<decltype(mutex_)> lock(mutex_);
-    if (categories_.find(category->id()) != categories_.end())
+    auto id = category->id();
+    auto it = find_if(categories_.begin(), categories_.end(), [id](const CatPair& p) { return p.first == id; });
+    if (it != categories_.end())
     {
-        std::ostringstream s;
-        s << "Category " << category->id() << " already defined";
-        throw InvalidArgumentException(s.str());
+        throw InvalidArgumentException("register_category(): duplicate category: " + id);
     }
-    categories_[category->id()] = category;
+    categories_.push_back(make_pair(category->id(), category));
 }
 
 Category::SCPtr CategoryRegistry::register_category(VariantMap const& variant_map)
@@ -58,7 +60,7 @@
 Category::SCPtr CategoryRegistry::lookup_category(std::string const& id) const
 {
     std::lock_guard<decltype(mutex_)> lock(mutex_);
-    auto it = categories_.find(id);
+    auto it = find_if(categories_.begin(), categories_.end(), [id](const CatPair& p) { return p.first == id; });
     if (it != categories_.end())
     {
         return it->second;
@@ -66,6 +68,17 @@
     return nullptr;
 }
 
+VariantArray CategoryRegistry::serialize() const
+{
+    std::lock_guard<decltype(mutex_)> lock(mutex_);
+    VariantArray va;
+    for (auto&& p : categories_)
+    {
+        va.push_back(Variant(p.second->serialize()));
+    }
+    return va;
+}
+
 } // namespace internal
 
 } // namespace scopes

=== modified file 'src/scopes/internal/QueryObject.cpp'
--- src/scopes/internal/QueryObject.cpp	2015-01-09 03:16:51 +0000
+++ src/scopes/internal/QueryObject.cpp	2015-02-05 09:36:37 +0000
@@ -104,6 +104,7 @@
     auto reply_proxy = make_shared<SearchReplyImpl>(reply,
                                                     self_,
                                                     cardinality_,
+                                                    search_query->query().query_string(),
                                                     search_query->department_id());
     assert(reply_proxy);
     reply_proxy_ = reply_proxy;

=== modified file 'src/scopes/internal/RuntimeImpl.cpp'
--- src/scopes/internal/RuntimeImpl.cpp	2015-01-20 06:27:04 +0000
+++ src/scopes/internal/RuntimeImpl.cpp	2015-02-05 09:36:37 +0000
@@ -529,6 +529,16 @@
     }
 }
 
+string RuntimeImpl::cache_directory() const
+{
+    return find_cache_dir();
+}
+
+string RuntimeImpl::tmp_directory() const
+{
+    return find_tmp_dir();
+}
+
 string RuntimeImpl::demangled_id(string const& scope_id) const
 {
     // For scopes that are in a click package together with an app,

=== modified file 'src/scopes/internal/SearchReplyImpl.cpp'
--- src/scopes/internal/SearchReplyImpl.cpp	2015-01-09 03:16:51 +0000
+++ src/scopes/internal/SearchReplyImpl.cpp	2015-02-05 09:36:37 +0000
@@ -20,12 +20,18 @@
 #include <unity/scopes/internal/SearchReplyImpl.h>
 
 #include <unity/scopes/Annotation.h>
-#include <unity/scopes/CategorisedResult.h>
+#include <unity/scopes/internal/CategorisedResultImpl.h>
 #include <unity/scopes/internal/DepartmentImpl.h>
+#include <unity/scopes/internal/FilterBaseImpl.h>
+#include <unity/scopes/internal/FilterStateImpl.h>
 #include <unity/scopes/internal/MWReply.h>
-#include <unity/scopes/internal/FilterBaseImpl.h>
 #include <unity/scopes/internal/QueryObjectBase.h>
+#include <unity/scopes/internal/RuntimeImpl.h>
+#include <unity/scopes/ScopeExceptions.h>
 #include <unity/UnityExceptions.h>
+#include <unity/util/FileIO.h>
+
+#include <stdlib.h>
 
 using namespace std;
 
@@ -39,20 +45,24 @@
 {
 
 SearchReplyImpl::SearchReplyImpl(MWReplyProxy const& mw_proxy,
-                                 std::shared_ptr<QueryObjectBase> const& qo,
+                                 shared_ptr<QueryObjectBase> const& qo,
                                  int cardinality,
-                                 std::string const& current_department_id)
+                                 string const& query_string,
+                                 string const& current_department_id)
     : ObjectImpl(mw_proxy)
     , ReplyImpl(mw_proxy, qo)
     , cat_registry_(new CategoryRegistry())
     , cardinality_(cardinality)
     , num_pushes_(0)
+    , finished_(false)
+    , query_string_(query_string)
     , current_department_(current_department_id)
 {
 }
 
 SearchReplyImpl::~SearchReplyImpl()
 {
+    finished();
 }
 
 void SearchReplyImpl::register_departments(Department::SCPtr const& parent)
@@ -67,6 +77,12 @@
         throw unity::LogicException("SearchReplyImpl::register_departments(): Failed to validate departments");
     }
 
+    if (query_string_.empty())
+    {
+        lock_guard<mutex> lock(mutex_);
+        cached_departments_ = parent;
+    }
+
     ReplyImpl::push(internal::DepartmentImpl::serialize_departments(parent)); // ignore return value?
 }
 
@@ -76,10 +92,10 @@
     push(category);
 }
 
-Category::SCPtr SearchReplyImpl::register_category(std::string const& id,
-                                             std::string const& title,
-                                             std::string const &icon,
-                                             CategoryRenderer const& renderer_template)
+Category::SCPtr SearchReplyImpl::register_category(string const& id,
+                                                   string const& title,
+                                                   string const &icon,
+                                                   CategoryRenderer const& renderer_template)
 {
     // will throw if adding same category again
     auto cat = cat_registry_->register_category(id, title, icon, nullptr, renderer_template);
@@ -87,11 +103,11 @@
     return cat;
 }
 
-Category::SCPtr SearchReplyImpl::register_category(std::string const& id,
-                                             std::string const& title,
-                                             std::string const& icon,
-                                             CannedQuery const& query,
-                                             CategoryRenderer const& renderer_template)
+Category::SCPtr SearchReplyImpl::register_category(string const& id,
+                                                   string const& title,
+                                                   string const& icon,
+                                                   CannedQuery const& query,
+                                                   CategoryRenderer const& renderer_template)
 {
     // will throw if adding same category again
     auto cat = cat_registry_->register_category(id, title, icon, make_shared<CannedQuery>(query), renderer_template);
@@ -99,7 +115,7 @@
     return cat;
 }
 
-Category::SCPtr SearchReplyImpl::lookup_category(std::string const& id)
+Category::SCPtr SearchReplyImpl::lookup_category(string const& id)
 {
     return cat_registry_->lookup_category(id);
 }
@@ -127,6 +143,14 @@
         return false;
     }
 
+    // We cache the results of surfacing queries so, if a scope has not connectivity,
+    // we can replay the results of the last successful surfacing query.
+    if (query_string_.empty())
+    {
+        lock_guard<mutex> lock(mutex_);
+        cached_results_.push_back(result);
+    }
+
     // Enforce cardinality limit (0 means no limit). If the scope pushes more results
     // than requested, future pushes are ignored. push() returns false
     // on the last call that actually still pushed a result.
@@ -153,6 +177,13 @@
         throw unity::LogicException("SearchReplyImpl::push(): Failed to validate filters");
     }
 
+    if (query_string_.empty())
+    {
+        lock_guard<mutex> lock(mutex_);
+        cached_filters_ = filters;
+        cached_filter_state_ = filter_state;
+    }
+
     VariantMap var;
     var["filters"] = internal::FilterBaseImpl::serialize_filters(filters);
     var["filter_state"] = filter_state.serialize();
@@ -166,6 +197,220 @@
     return ReplyImpl::push(var);
 }
 
+void SearchReplyImpl::finished()
+{
+    if (finished_.exchange(true))
+    {
+        return;
+    }
+    write_cached_results();
+    ReplyImpl::finished();  // Upcall to deal with the normal case
+}
+
+static constexpr char const* cache_file_name = ".surfacing_cache";
+
+void SearchReplyImpl::write_cached_results() noexcept
+{
+    assert(finished_);
+
+    if (!query_string_.empty())
+    {
+        return;  // Caching applies only to surfacing queries
+    }
+
+    string tmp_path;
+    try
+    {
+        // Open a temporary file for writing.
+        tmp_path = mw_proxy_->mw_base()->runtime()->cache_directory() + "/" + cache_file_name + "XXXXXX";
+        auto opener = [tmp_path]()
+        {
+            int tmp_fd = mkstemp(const_cast<char*>(tmp_path.c_str()));
+            if (tmp_fd == -1)
+            {
+                throw FileException("cannot open tmp file " + tmp_path, errno);
+            }
+            return tmp_fd;
+        };
+        auto closer = [tmp_path](int fd)
+        {
+            if (::close(fd) == -1)
+            {
+                // LCOV_EXCL_START
+                throw FileException("cannot close tmp file " + tmp_path + " (fd = " + std::to_string(fd) + ")", errno);
+                // LCOV_EXCL_STOP
+            }
+        };
+        unity::util::ResourcePtr<int, decltype(closer)> tmp_file(opener(), closer);
+
+        // Turn departments, categories, and results into a JSON string.
+        VariantMap departments;
+        if (cached_departments_)
+        {
+            departments = cached_departments_->serialize();
+        }
+        auto filters = internal::FilterBaseImpl::serialize_filters(cached_filters_);
+        auto filter_state = cached_filter_state_.serialize();
+        VariantArray categories = cat_registry_->serialize();
+        VariantArray results;
+        for (auto const& r : cached_results_)
+        {
+            results.push_back(Variant(r.serialize()));
+        }
+        VariantMap vm;
+        vm["departments"] = move(departments);
+        vm["categories"] = move(categories);
+        vm["filters"] = move(filters);
+        vm["filter_state"] = move(filter_state);
+        vm["results"] = move(results);
+        string const json = Variant(move(vm)).serialize_json();
+
+        // Write tmp file.
+        if (::write(tmp_file.get(), json.c_str(), json.size()) != static_cast<int>(json.size()))
+        {
+            // LCOV_EXCL_START
+            throw FileException("cannot write tmp file " + tmp_path + " (fd = " + std::to_string(tmp_file.get()) + ")",
+                                errno);
+            // LCOV_EXCL_STOP
+        }
+        tmp_file.dealloc();  // Close tmp file.
+
+        // Atomically replace the old cache with the new one.
+        string cache_path = mw_proxy_->mw_base()->runtime()->cache_directory() + "/" + cache_file_name;
+        if (rename(tmp_path.c_str(), cache_path.c_str()) == -1)
+        {
+            throw FileException("cannot rename tmp file " + tmp_path + " to " + cache_path, errno);  // LCOV_EXCL_LINE
+        }
+    }
+    catch (std::exception const& e)
+    {
+        ::unlink(tmp_path.c_str());
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "SearchReply::write_cached_results(): " << e.what();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        ::unlink(tmp_path.c_str());
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "SearchReply::write_cached_results(): unknown exception";
+    }
+    // LCOV_EXCL_STOP
+}
+
+void SearchReplyImpl::push_surfacing_results_from_cache() noexcept
+{
+    if (!query_string_.empty())
+    {
+        return;  // Caching applies only to surfacing queries
+    }
+
+    if (finished_.exchange(true))
+    {
+        return;
+    }
+
+    string cache_path = mw_proxy_->mw_base()->runtime()->cache_directory() + "/" + cache_file_name;
+    try
+    {
+        // Read cache file.
+        string json;
+        try
+        {
+            json = unity::util::read_text_file(cache_path);
+        }
+        catch (unity::FileException const& e)
+        {
+            if (e.error() == ENOENT)
+            {
+                ReplyImpl::finished();
+                return;  // No cache has been written yet.
+            }
+            throw;
+        }
+
+        // Decode JSON for the three sections.
+        Variant v(Variant::deserialize_json(json));
+        VariantMap vm = v.get_dict();
+
+        auto it = vm.find("departments");
+        if (it == vm.end())
+        {
+            throw unity::scopes::NotFoundException("malformed cache file", "departments");
+        }
+        auto department_dict = it->second.get_dict();
+
+        it = vm.find("categories");
+        if (it == vm.end())
+        {
+            throw unity::scopes::NotFoundException("malformed cache file", "categories");
+        }
+        auto category_array = it->second.get_array();
+
+        it = vm.find("filters");
+        if (it == vm.end())
+        {
+            throw unity::scopes::NotFoundException("malformed cache file", "filters");
+        }
+        auto filter_array = it->second.get_array();
+
+        it = vm.find("filter_state");
+        if (it == vm.end())
+        {
+            throw unity::scopes::NotFoundException("malformed cache file", "filter_state");
+        }
+        auto filter_state_dict = it->second.get_dict();
+
+        it = vm.find("results");
+        if (it == vm.end())
+        {
+            throw unity::scopes::NotFoundException("malformed cache file", "results");
+        }
+        auto result_array = it->second.get_array();
+
+        // We have the JSON strings as Variants, re-create the native representations
+        // and re-instate them.
+        if (!department_dict.empty())
+        {
+            auto departments = DepartmentImpl::create(move(department_dict));
+            register_departments(move(departments));
+        }
+
+        for (auto const& c : category_array)
+        {
+            // Can't use make_shared here because that isn't a friend of Category.
+            auto cp = Category::SCPtr(new Category(move(c.get_dict())));
+            register_category(cp);
+        }
+
+        auto filters = FilterBaseImpl::deserialize_filters(move(filter_array));
+        auto filter_state = FilterStateImpl::deserialize(move(filter_state_dict));
+        push(filters, filter_state);
+
+        for (auto const& r : result_array)
+        {
+            VariantMap dict = r.get_dict();
+            auto cr = CategorisedResult(new CategorisedResultImpl(*cat_registry_, dict));
+            push(cr);
+        }
+    }
+    catch (std::exception const& e)
+    {
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "SearchReply::push_surfacing_results_from_cache() (file = " + cache_path + "): " << e.what();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "SearchReply::push_surfacing_results_from_cache() (file = " + cache_path + "): unknown exception";
+    }
+    // LCOV_EXCL_STOP
+
+    // Query is complete.
+    ReplyImpl::finished();
+}
+
 } // namespace internal
 
 } // namespace scopes

=== modified file 'src/scopes/internal/smartscopes/SSQueryObject.cpp'
--- src/scopes/internal/smartscopes/SSQueryObject.cpp	2015-01-09 03:16:51 +0000
+++ src/scopes/internal/smartscopes/SSQueryObject.cpp	2015-02-05 09:36:37 +0000
@@ -207,6 +207,7 @@
     q_reply_proxy = make_shared<SearchReplyImpl>(reply,
                                                  shared_from_this(),
                                                  query->q_cardinality,
+                                                 q_base->query().query_string(),
                                                  q_base->department_id());
     assert(q_reply_proxy);
     query->q_reply_proxy = q_reply_proxy;

=== modified file 'src/scopes/testing/InProcessBenchmark.cpp'
--- src/scopes/testing/InProcessBenchmark.cpp	2014-08-28 00:20:56 +0000
+++ src/scopes/testing/InProcessBenchmark.cpp	2015-02-05 09:36:37 +0000
@@ -208,6 +208,10 @@
     {
         return true;
     }
+
+    void push_surfacing_results_from_cache() override
+    {
+    }
 };
 
 typedef std::chrono::high_resolution_clock Clock;

=== modified file 'src/scopes/utility/internal/BufferedSearchReplyImpl.cpp'
--- src/scopes/utility/internal/BufferedSearchReplyImpl.cpp	2014-12-01 01:51:38 +0000
+++ src/scopes/utility/internal/BufferedSearchReplyImpl.cpp	2015-02-05 09:36:37 +0000
@@ -92,6 +92,11 @@
     return upstream_->push(filters, filter_state);
 }
 
+void BufferedSearchReplyImpl::push_surfacing_results_from_cache()
+{
+    upstream_->push_surfacing_results_from_cache();
+}
+
 void BufferedSearchReplyImpl::finished()
 {
     upstream_->finished();

=== modified file 'test/gtest/scopes/CMakeLists.txt'
--- test/gtest/scopes/CMakeLists.txt	2015-01-26 08:20:45 +0000
+++ test/gtest/scopes/CMakeLists.txt	2015-02-05 09:36:37 +0000
@@ -27,6 +27,7 @@
 add_subdirectory(RangeInputFilter)
 add_subdirectory(RatingFilter)
 add_subdirectory(ReplyReaper)
+add_subdirectory(ResultCache)
 add_subdirectory(SwitchFilter)
 add_subdirectory(ValueSliderFilter)
 add_subdirectory(PreviewWidget)

=== added directory 'test/gtest/scopes/ResultCache'
=== added file 'test/gtest/scopes/ResultCache/CMakeLists.txt'
--- test/gtest/scopes/ResultCache/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/CMakeLists.txt	2015-02-05 09:36:37 +0000
@@ -0,0 +1,27 @@
+configure_file(TestRegistry.ini.in ${CMAKE_CURRENT_BINARY_DIR}/TestRegistry.ini)
+configure_file(Runtime.ini.in ${CMAKE_CURRENT_BINARY_DIR}/Runtime.ini)
+configure_file(Zmq.ini.in ${CMAKE_CURRENT_BINARY_DIR}/Zmq.ini)
+
+add_definitions(-DTEST_SOURCE_PATH="${CMAKE_CURRENT_SOURCE_DIR}")
+add_definitions(-DTEST_RUNTIME_PATH="${CMAKE_CURRENT_BINARY_DIR}")
+add_definitions(-DTEST_RUNTIME_FILE="${CMAKE_CURRENT_BINARY_DIR}/Runtime.ini")
+add_definitions(-DTEST_REGISTRY_PATH="${PROJECT_BINARY_DIR}/scoperegistry")
+
+add_executable(ResultCache_test ResultCache_test.cpp CacheScope.cpp)
+target_link_libraries(ResultCache_test ${TESTLIBS})
+
+add_dependencies(ResultCache_test scoperegistry scoperunner)
+
+add_test(ResultCache ResultCache_test)
+
+set(SCOPE_DIR "${CMAKE_CURRENT_BINARY_DIR}/scopes")
+
+foreach (scope CacheScope AlwaysPushFromCacheScope)
+    file(MAKE_DIRECTORY "${SCOPE_DIR}/${scope}")
+    configure_file(CacheScope.ini.in ${SCOPE_DIR}/${scope}/${scope}.ini)
+    add_library(${scope} MODULE CacheScope.cpp)
+    set_target_properties(${scope}
+      PROPERTIES
+        LIBRARY_OUTPUT_DIRECTORY "${SCOPE_DIR}/${scope}/"
+    )
+endforeach()

=== added file 'test/gtest/scopes/ResultCache/CacheScope.cpp'
--- test/gtest/scopes/ResultCache/CacheScope.cpp	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/CacheScope.cpp	2015-02-05 09:36:37 +0000
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2015 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include "CacheScope.h"
+
+#include <unity/scopes/CategorisedResult.h>
+#include <unity/scopes/OptionSelectorFilter.h>
+#include <unity/scopes/ScopeBase.h>
+#include <unity/scopes/ScopeExceptions.h>
+#include <unity/scopes/SearchReply.h>
+
+#include <boost/filesystem.hpp>
+#include <unity/UnityExceptions.h>
+#include <unity/util/FileIO.h>
+
+#include <atomic>
+#include <mutex>
+
+using namespace std;
+using namespace unity::scopes;
+
+namespace
+{
+
+class TestQuery : public SearchQueryBase
+{
+public:
+    TestQuery(CannedQuery const& query,
+              SearchMetadata const& metadata,
+              string const& id,
+              RegistryProxy const& reg)
+        : SearchQueryBase(query, metadata)
+        , id_(id)
+        , registry_(reg)
+    {
+    }
+
+    virtual void cancelled() override
+    {
+    }
+
+    virtual void run(SearchReplyProxy const& reply) override
+    {
+        if (id_ == "AlwaysPushFromCacheScope")
+        {
+            // So we get coverage on pushing from cache before a cache file exists.
+            reply->push_surfacing_results_from_cache();
+            return;
+        }
+
+        if (query().query_string().empty())
+        {
+            // If there is a cache file, we use it to push.
+            boost::system::error_code ec;
+            if (boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec))
+            {
+                reply->push_surfacing_results_from_cache();
+                // We do this twice, to get coverage on the double-call guard.
+                reply->push_surfacing_results_from_cache();
+                return;
+            }
+        }
+        else if (query().query_string() == "non-empty from cache")
+        {
+            // This gives us coverage for the case that we are pushing from the cache for a non-empty query.
+            reply->push_surfacing_results_from_cache();
+            return;
+        }
+
+        auto depts = Department::create("", query(), "Top");
+        auto sub_dept = Department::create("sub" + query().query_string(), query(), "Sub");
+        depts->add_subdepartment(move(sub_dept));
+        reply->register_departments(move(depts));
+
+        Filters filters;
+        OptionSelectorFilter::SPtr filter = OptionSelectorFilter::create("f1", "Choose an option", false);
+        filter->add_option("o1", "Option 1");
+        auto active_opt = filter->add_option("o2", "Option 2");
+        FilterState fstate;
+        filter->update_state(fstate, active_opt, true);
+        filters.push_back(filter);
+        if (valid())
+        {
+            reply->push(filters, fstate);
+        }
+
+        auto cat = reply->register_category(id_, "", "");
+        CategorisedResult res(cat);
+        res.set_uri("uri");
+        res.set_title(query().query_string());
+        if (valid())
+        {
+            reply->push(res);
+        }
+    }
+
+private:
+    string id_;
+    RegistryProxy registry_;
+};
+
+}  // namespace
+
+void CacheScope::start(string const& scope_id)
+{
+    lock_guard<mutex> lock(mutex_);
+    id_ = scope_id;
+}
+
+void CacheScope::stop()
+{
+}
+
+void CacheScope::run()
+{
+}
+
+SearchQueryBase::UPtr CacheScope::search(CannedQuery const& query, SearchMetadata const& metadata)
+{
+    lock_guard<mutex> lock(mutex_);
+    return SearchQueryBase::UPtr(new TestQuery(query, metadata, id_, registry()));
+}
+
+PreviewQueryBase::UPtr CacheScope::preview(Result const&, ActionMetadata const &)
+{
+    return nullptr;  // unused
+}
+
+extern "C"
+{
+
+    unity::scopes::ScopeBase*
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_CREATE_FUNCTION()
+    {
+        return new CacheScope;
+    }
+
+    void
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_DESTROY_FUNCTION(unity::scopes::ScopeBase* scope_base)
+    {
+        delete scope_base;
+    }
+}

=== added file 'test/gtest/scopes/ResultCache/CacheScope.h'
--- test/gtest/scopes/ResultCache/CacheScope.h	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/CacheScope.h	2015-02-05 09:36:37 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2015 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/scopes/ScopeBase.h>
+
+class CacheScope : public unity::scopes::ScopeBase
+{
+public:
+    virtual void start(std::string const&) override;
+
+    virtual void stop() override;
+
+    virtual void run() override;
+
+    virtual unity::scopes::SearchQueryBase::UPtr search(unity::scopes::CannedQuery const &,
+                                                        unity::scopes::SearchMetadata const &) override;
+
+    virtual unity::scopes::PreviewQueryBase::UPtr preview(unity::scopes::Result const&,
+                                                          unity::scopes::ActionMetadata const &) override;
+
+private:
+    std::string id_;
+    std::mutex mutex_;
+};

=== added file 'test/gtest/scopes/ResultCache/CacheScope.ini.in'
--- test/gtest/scopes/ResultCache/CacheScope.ini.in	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/CacheScope.ini.in	2015-02-05 09:36:37 +0000
@@ -0,0 +1,4 @@
+[ScopeConfig]
+DisplayName = CacheScope
+Description = Scope that pushes cached results for surfacing query
+Author = Michi

=== added file 'test/gtest/scopes/ResultCache/ResultCache_test.cpp'
--- test/gtest/scopes/ResultCache/ResultCache_test.cpp	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/ResultCache_test.cpp	2015-02-05 09:36:37 +0000
@@ -0,0 +1,414 @@
+/*
+ * Copyright (C) 2015 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/scopes/CategorisedResult.h>
+#include <unity/scopes/internal/RegistryObject.h>
+#include <unity/scopes/internal/RuntimeImpl.h>
+#include <unity/scopes/internal/ScopeImpl.h>
+#include <unity/scopes/OptionSelectorFilter.h>
+
+#include <boost/filesystem.hpp>
+#include <gtest/gtest.h>
+
+#include "CacheScope.h"
+
+using namespace std;
+using namespace unity::scopes;
+using namespace unity::scopes::internal;
+
+class Receiver : public SearchListenerBase
+{
+public:
+    Receiver()
+        : query_complete_(false)
+    {
+    }
+
+    virtual void push(Department::SCPtr const& parent) override
+    {
+        lock_guard<mutex> lock(mutex_);
+        dept_ = parent;
+    }
+
+    virtual void push(Filters const& filters, FilterState const& filter_state) override
+    {
+        lock_guard<mutex> lock(mutex_);
+        filters_ = filters;
+        filter_state_ = filter_state;
+    }
+
+    virtual void push(CategorisedResult result) override
+    {
+        lock_guard<mutex> lock(mutex_);
+        result_ = make_shared<CategorisedResult>(result);
+    }
+
+    virtual void finished(CompletionDetails const& details) override
+    {
+        EXPECT_EQ(CompletionDetails::OK, details.status()) << details.message();
+        lock_guard<mutex> lock(mutex_);
+        query_complete_ = true;
+        cond_.notify_one();
+    }
+
+    void wait_until_finished()
+    {
+        unique_lock<mutex> lock(mutex_);
+        cond_.wait(lock, [this] { return this->query_complete_; });
+        query_complete_ = false;
+    }
+
+    Department::SCPtr dept() const
+    {
+        lock_guard<mutex> lock(mutex_);
+        return dept_;
+    }
+
+    Filters filters() const
+    {
+        lock_guard<mutex> lock(mutex_);
+        return filters_;
+    }
+
+    FilterState filter_state() const
+    {
+        lock_guard<mutex> lock(mutex_);
+        return filter_state_;
+    }
+
+    CategorisedResult::SCPtr result() const
+    {
+        lock_guard<mutex> lock(mutex_);
+        return result_;
+    }
+
+private:
+    Department::SCPtr dept_;
+    Filters filters_;
+    FilterState filter_state_;
+    CategorisedResult::SCPtr result_;
+    bool query_complete_;
+    mutable mutex mutex_;
+    condition_variable cond_;
+};
+
+class CacheScopeTest : public ::testing::Test
+{
+public:
+    CacheScopeTest()
+    {
+        runtime_ = Runtime::create(TEST_RUNTIME_FILE);
+        auto reg = runtime_->registry();
+        auto meta = reg->get_metadata("CacheScope");
+        scope_ = meta.proxy();
+        meta = reg->get_metadata("AlwaysPushFromCacheScope");
+        always_push_from_cache_scope_ = meta.proxy();
+    }
+
+    ScopeProxy scope() const
+    {
+        return scope_;
+    }
+
+    ScopeProxy always_push_from_cache_scope() const
+    {
+        return always_push_from_cache_scope_;
+    }
+
+private:
+    Runtime::UPtr runtime_;
+    ScopeProxy scope_;
+    ScopeProxy always_push_from_cache_scope_;
+};
+
+TEST_F(CacheScopeTest, push_from_cache_without_cache_file)
+{
+    ::unlink(TEST_RUNTIME_PATH "/unconfined/AlwaysPushFromCacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    always_push_from_cache_scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r, nullptr);
+}
+
+TEST_F(CacheScopeTest, non_surfacing_query)
+{
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope", 0700);
+    ::unlink(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("some query", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "some query");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "subsome query");
+
+    // Non-empty query, so there must be no cache file.
+    boost::system::error_code ec;
+    EXPECT_FALSE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, surfacing_query)
+{
+    ::unlink(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "sub");
+
+    // Empty query, so there must be a cache file.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+    system("cat " TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+}
+
+// Run another non-surfacing query before checking that the cache contains the
+// results of the last surfacing query.
+
+TEST_F(CacheScopeTest, non_surfacing_query2)
+{
+    auto receiver = make_shared<Receiver>();
+    scope()->search("some other query", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "some other query");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "subsome other query");
+
+    // Cache file must still be there.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, push_from_cache)
+{
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "sub");
+    auto filters = receiver->filters();
+    ASSERT_EQ(1, filters.size());
+    auto f = *filters.begin();
+    EXPECT_EQ("option_selector", f->filter_type());
+    auto osf = dynamic_pointer_cast<OptionSelectorFilter const>(f);
+    ASSERT_TRUE(osf != nullptr);
+    EXPECT_EQ("Choose an option", osf->label());
+    auto fs = receiver->filter_state();
+    EXPECT_TRUE(fs.has_filter("f1"));
+    EXPECT_TRUE(osf->has_active_option(fs));
+
+    // Cache file must still be there.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, push_non_empty_from_cache)
+{
+    auto receiver = make_shared<Receiver>();
+    scope()->search("non-empty from cache", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    // Cache file must still be there.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, write_failure)
+{
+    ::unlink(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope", 0);
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    // Empty query, but cache file could not be created
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope", 0700);
+    boost::system::error_code ec;
+    EXPECT_FALSE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, surfacing_query_2)
+{
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "sub");
+    auto filters = receiver->filters();
+    ASSERT_EQ(1, filters.size());
+    auto f = *filters.begin();
+    EXPECT_EQ("option_selector", f->filter_type());
+    auto osf = dynamic_pointer_cast<OptionSelectorFilter const>(f);
+    ASSERT_TRUE(osf != nullptr);
+    EXPECT_EQ("Choose an option", osf->label());
+    auto fs = receiver->filter_state();
+    EXPECT_TRUE(fs.has_filter("f1"));
+    EXPECT_TRUE(osf->has_active_option(fs));
+
+    // New cache file must have been created
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, read_failure)
+{
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", 0);
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", 0600);
+
+    // Cache file must still be there, but read will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+// Stop warnings about unused return value from system()
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-result"
+
+TEST_F(CacheScopeTest, missing_departments)
+{
+    // Get coverage on missing departments entry
+    system("cp " TEST_SOURCE_PATH "/no_dept_cache " TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+
+    // Cache file must still be there, but decode will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, missing_categories)
+{
+    // Get coverage on missing categories entry
+    system("cp " TEST_SOURCE_PATH "/no_cat_cache " TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+
+    // Cache file must still be there, but decode will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, missing_filters)
+{
+    // Get coverage on missing filters entry
+    system("cp " TEST_SOURCE_PATH "/no_filters_cache " TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+
+    // Cache file must still be there, but decode will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, missing_filter_state)
+{
+    // Get coverage on missing filters_state entry
+    system("cp " TEST_SOURCE_PATH "/no_filter_state_cache " TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+
+    // Cache file must still be there, but decode will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, missing_results)
+{
+    // Get coverage on missing results entry
+    system("cp " TEST_SOURCE_PATH "/no_results_cache " TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+
+    // Cache file must still be there, but decode will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+#pragma GCC diagnostic pop
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+
+    int rc = 0;
+
+    // Set the "TEST_DESKTOP_FILES_DIR" env var before forking as not to create desktop files in ~/.local
+    putenv(const_cast<char*>("TEST_DESKTOP_FILES_DIR=" TEST_RUNTIME_PATH));
+
+    auto rpid = fork();
+    if (rpid == 0)
+    {
+        const char* const args[] = {"scoperegistry [CacheScope_test]", TEST_RUNTIME_FILE, nullptr};
+        if (execv(TEST_REGISTRY_PATH "/scoperegistry", const_cast<char* const*>(args)) < 0)
+        {
+            perror("Error starting scoperegistry:");
+        }
+        return 1;
+    }
+    else if (rpid > 0)
+    {
+        rc = RUN_ALL_TESTS();
+        kill(rpid, SIGTERM);
+        waitpid(rpid, nullptr, 0);
+    }
+    else
+    {
+        perror("Failed to fork:");
+    }
+
+    return rc;
+}

=== added file 'test/gtest/scopes/ResultCache/Runtime.ini.in'
--- test/gtest/scopes/ResultCache/Runtime.ini.in	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/Runtime.ini.in	2015-02-05 09:36:37 +0000
@@ -0,0 +1,8 @@
+[Runtime]
+Registry.Identity = TestRegistry
+Registry.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/TestRegistry.ini
+Default.Middleware = Zmq
+Zmq.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Zmq.ini
+Smartscopes.Registry.Identity =
+CacheDir=@CMAKE_CURRENT_BINARY_DIR@
+LogDir=

=== added file 'test/gtest/scopes/ResultCache/TestRegistry.ini.in'
--- test/gtest/scopes/ResultCache/TestRegistry.ini.in	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/TestRegistry.ini.in	2015-02-05 09:36:37 +0000
@@ -0,0 +1,7 @@
+[Registry]
+Middleware = Zmq
+Zmq.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Zmq.ini
+Scope.InstallDir = @CMAKE_CURRENT_BINARY_DIR@/scopes
+OEM.InstallDir = /unused
+Click.InstallDir = @CMAKE_CURRENT_BINARY_DIR@/click
+Scoperunner.Path = @PROJECT_BINARY_DIR@/scoperunner/scoperunner

=== added file 'test/gtest/scopes/ResultCache/Zmq.ini.in'
--- test/gtest/scopes/ResultCache/Zmq.ini.in	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/Zmq.ini.in	2015-02-05 09:36:37 +0000
@@ -0,0 +1,2 @@
+[Zmq]
+EndpointDir = /tmp

=== added file 'test/gtest/scopes/ResultCache/no_cat_cache'
--- test/gtest/scopes/ResultCache/no_cat_cache	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/no_cat_cache	2015-02-05 09:36:37 +0000
@@ -0,0 +1,1 @@
+{"departments":{"departments":[{"label":"Sub","query":{"department_id":"sub","filter_state":{},"query_string":"","scope":"CacheScope"}}],"label":"Top","query":{"department_id":"","filter_state":{},"query_string":"","scope":"CacheScope"}},"filter_state":{"f1":["o2"]},"filters":[{"filter_type":"option_selector","id":"f1","label":"Choose an option","multi_select":false,"options":[{"id":"o1","label":"Option 1"},{"id":"o2","label":"Option 2"}]}],"results":[{"attrs":{"title":"","uri":"uri"},"internal":{"cat_id":"CacheScope"}}]}

=== added file 'test/gtest/scopes/ResultCache/no_dept_cache'
--- test/gtest/scopes/ResultCache/no_dept_cache	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/no_dept_cache	2015-02-05 09:36:37 +0000
@@ -0,0 +1,1 @@
+{"categories":[{"icon":"","id":"CacheScope","renderer_template":"\n    {\n        \"schema-version\":1,\n        \"template\":\n        {\n            \"category-layout\":\"grid\"\n        },\n        \"components\":\n        {\n            \"title\":\"title\",\n            \"art\":\"art\"\n        }\n    }\n    ","title":""}],"filter_state":{"f1":["o2"]},"filters":[{"filter_type":"option_selector","id":"f1","label":"Choose an option","multi_select":false,"options":[{"id":"o1","label":"Option 1"},{"id":"o2","label":"Option 2"}]}],"results":[{"attrs":{"title":"","uri":"uri"},"internal":{"cat_id":"CacheScope"}}]}

=== added file 'test/gtest/scopes/ResultCache/no_filter_state_cache'
--- test/gtest/scopes/ResultCache/no_filter_state_cache	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/no_filter_state_cache	2015-02-05 09:36:37 +0000
@@ -0,0 +1,1 @@
+{"categories":[{"icon":"","id":"CacheScope","renderer_template":"\n    {\n        \"schema-version\":1,\n        \"template\":\n        {\n            \"category-layout\":\"grid\"\n        },\n        \"components\":\n        {\n            \"title\":\"title\",\n            \"art\":\"art\"\n        }\n    }\n    ","title":""}],"departments":{"departments":[{"label":"Sub","query":{"department_id":"sub","filter_state":{},"query_string":"","scope":"CacheScope"}}],"label":"Top","query":{"department_id":"","filter_state":{},"query_string":"","scope":"CacheScope"}},"filters":[{"filter_type":"option_selector","id":"f1","label":"Choose an option","multi_select":false,"options":[{"id":"o1","label":"Option 1"},{"id":"o2","label":"Option 2"}]}],"results":[{"attrs":{"title":"","uri":"uri"},"internal":{"cat_id":"CacheScope"}}]}

=== added file 'test/gtest/scopes/ResultCache/no_filters_cache'
--- test/gtest/scopes/ResultCache/no_filters_cache	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/no_filters_cache	2015-02-05 09:36:37 +0000
@@ -0,0 +1,1 @@
+{"categories":[{"icon":"","id":"CacheScope","renderer_template":"\n    {\n        \"schema-version\":1,\n        \"template\":\n        {\n            \"category-layout\":\"grid\"\n        },\n        \"components\":\n        {\n            \"title\":\"title\",\n            \"art\":\"art\"\n        }\n    }\n    ","title":""}],"departments":{"departments":[{"label":"Sub","query":{"department_id":"sub","filter_state":{},"query_string":"","scope":"CacheScope"}}],"label":"Top","query":{"department_id":"","filter_state":{},"query_string":"","scope":"CacheScope"}},"filter_state":{"f1":["o2"]},"results":[{"attrs":{"title":"","uri":"uri"},"internal":{"cat_id":"CacheScope"}}]}

=== added file 'test/gtest/scopes/ResultCache/no_results_cache'
--- test/gtest/scopes/ResultCache/no_results_cache	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/no_results_cache	2015-02-05 09:36:37 +0000
@@ -0,0 +1,1 @@
+{"categories":[{"icon":"","id":"CacheScope","renderer_template":"\n    {\n        \"schema-version\":1,\n        \"template\":\n        {\n            \"category-layout\":\"grid\"\n        },\n        \"components\":\n        {\n            \"title\":\"title\",\n            \"art\":\"art\"\n        }\n    }\n    ","title":""}],"departments":{"departments":[{"label":"Sub","query":{"department_id":"sub","filter_state":{},"query_string":"","scope":"CacheScope"}}],"label":"Top","query":{"department_id":"","filter_state":{},"query_string":"","scope":"CacheScope"}},"filter_state":{"f1":["o2"]},"filters":[{"filter_type":"option_selector","id":"f1","label":"Choose an option","multi_select":false,"options":[{"id":"o1","label":"Option 1"},{"id":"o2","label":"Option 2"}]}]}

=== added directory 'test/gtest/scopes/ResultCache/unconfined'
=== added directory 'test/gtest/scopes/ResultCache/unconfined/CacheScope'
=== modified file 'test/gtest/scopes/internal/RuntimeConfig/RuntimeConfig_test.cpp'
--- test/gtest/scopes/internal/RuntimeConfig/RuntimeConfig_test.cpp	2015-01-09 03:16:51 +0000
+++ test/gtest/scopes/internal/RuntimeConfig/RuntimeConfig_test.cpp	2015-02-05 09:36:37 +0000
@@ -23,6 +23,7 @@
 
 #include <unity/UnityExceptions.h>
 
+#include <boost/regex.hpp>  // Use Boost implementation until http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53631 is fixed.
 #include <gtest/gtest.h>
 
 using namespace std;
@@ -230,12 +231,16 @@
     }
     catch (ConfigException const& e)
     {
-        EXPECT_STREQ( "unity::scopes::ConfigException: \"" TEST_SRC_DIR "/NoLogDir.ini\": "
-                      "No LogDir configured and failed to get default:\n"
-                      "    unity::ResourceException: RuntimeConfig::default_log_directory(): $HOME not set:\n"
-                      "        unity::LogicException: Could not get string value (" TEST_SRC_DIR "/NoLogDir.ini, "
-                      "group: Runtime): Key file does not have key 'LogDir' in group 'Runtime'",
-                     e.what());
+        // Using regex here because error message returned by glib changed from Utopic to Vivid.
+        // The final .* takes care of the difference. Note that, instead of using TEST_SRC_DIR, we
+        // use .+. That's because, when building with bzr bd, we end up with a '+' in the path,
+        // and that is a regex metacharacter, causing the match to fail.
+        boost::regex r("unity::scopes::ConfigException: \".+/NoLogDir.ini\": "
+                       "No LogDir configured and failed to get default:\\n"
+                       "    unity::ResourceException: RuntimeConfig::default_log_directory\\(\\): \\$HOME not set:\\n"
+                       "        unity::LogicException: Could not get string value \\(.+/NoLogDir.ini, "
+                       "group: Runtime\\): Key file does not have key 'LogDir' in group 'Runtime'");
+        EXPECT_TRUE(boost::regex_match(e.what(), r)) << e.what();
     }
 
     try
@@ -247,9 +252,9 @@
     }
     catch (ConfigException const& e)
     {
-        EXPECT_STREQ( "unity::scopes::ConfigException: \"" TEST_SRC_DIR "/NoAppDir.ini\": "
-                      "No AppDir configured and failed to get default:\n"
-                      "    unity::ResourceException: RuntimeConfig::default_app_directory(): $HOME not set",
+        EXPECT_STREQ("unity::scopes::ConfigException: \"" TEST_SRC_DIR "/NoAppDir.ini\": "
+                     "No AppDir configured and failed to get default:\n"
+                     "    unity::ResourceException: RuntimeConfig::default_app_directory(): $HOME not set",
                      e.what());
     }