Merge lp:~stolowski/unity-scopes-shell/model-update-crashfix into lp:unity-scopes-shell

[Paweł Stołowski]

Fix crash on duplicated results - de-duplicate results (duplicates are ignored). Add stress tests for results model updates.

Fix crash on duplicated results. Add stress tests for results model updates (the test with "duplicated_results" search query triggers the crash without the fix).

[Michi Henning (michihenning)]

I'm not fond of the constructor that modifies its argument via a non-const reference.

But, seeing that this fixes this for now, I'm good with it.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:296
http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-ci/410/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-vivid-amd64-ci/104
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-vivid-armhf-ci/104
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-vivid-armhf-ci/104/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-vivid-i386-ci/104
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-wily-amd64-ci/67/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-wily-armhf-ci/67/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-shell-wily-i386-ci/67/console

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

review: Needs Fixing (continuous-integration)

[Paweł Stołowski (stolowski)]

Top-approving (agreed with Michi).

=== modified file 'src/Unity/resultsmap.cpp'
--- src/Unity/resultsmap.cpp	2015-10-06 14:35:18 +0000
+++ src/Unity/resultsmap.cpp	2016-02-16 08:14:59 +0000
@@ -25,14 +25,19 @@
     rebuild(results);
 }
 
-ResultsMap::ResultsMap(QList<std::shared_ptr<unity::scopes::CategorisedResult>> const &results)
+ResultsMap::ResultsMap(QList<std::shared_ptr<unity::scopes::CategorisedResult>> &results)
 {
     int pos = 0;
-    for (auto result: results) {
-        std::shared_ptr<unity::scopes::Result> res = result;
-        assert(res);
-        const ResultPos rpos { res, pos++ };
-        m_results.insert({result->uri(), rpos });
+    for (auto it = results.begin(); it != results.end(); ) {
+        std::shared_ptr<unity::scopes::Result> result = *it;
+        assert(result);
+        if (find(result) < 0) {
+            const ResultPos rpos { result, pos++ };
+            m_results.insert({result->uri(), rpos });
+            ++it;
+        } else {
+            it = results.erase(it);
+        }
     }
 }
 

=== modified file 'src/Unity/resultsmap.h'
--- src/Unity/resultsmap.h	2015-10-06 14:35:18 +0000
+++ src/Unity/resultsmap.h	2016-02-16 08:14:59 +0000
@@ -33,7 +33,9 @@
 {
     public:
         ResultsMap(QList<std::shared_ptr<unity::scopes::Result>> const &results);
-        ResultsMap(QList<std::shared_ptr<unity::scopes::CategorisedResult>> const &results);
+
+        // note: this constructor modifies the input results list (de-duplicates it).
+        ResultsMap(QList<std::shared_ptr<unity::scopes::CategorisedResult>> &results);
         int find(std::shared_ptr<unity::scopes::Result> const& result) const;
 
         void rebuild(QList<std::shared_ptr<unity::scopes::Result>> const &results);

=== modified file 'src/Unity/resultsmodel.cpp'
--- src/Unity/resultsmodel.cpp	2015-11-30 09:23:32 +0000
+++ src/Unity/resultsmodel.cpp	2016-02-16 08:14:59 +0000
@@ -73,7 +73,7 @@
     m_maxAttributes = count;
 }
 
-void ResultsModel::addUpdateResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>> const& results)
+void ResultsModel::addUpdateResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>>& results)
 {
     if (results.count() == 0) {
         return;
@@ -129,7 +129,7 @@
     }
 }
 
-void ResultsModel::addResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>> const& results)
+void ResultsModel::addResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>>& results)
 {
     if (results.count() == 0) {
         return;
@@ -137,6 +137,9 @@
 
     m_purge = false;
 
+    ResultsMap newResultsMap(results); // deduplicate results
+    Q_UNUSED(newResultsMap);
+
     beginInsertRows(QModelIndex(), m_results.count(), m_results.count() + results.count() - 1);
     Q_FOREACH(std::shared_ptr<scopes::CategorisedResult> const& result, results) {
         m_results.append(result);

=== modified file 'src/Unity/resultsmodel.h'
--- src/Unity/resultsmodel.h	2015-10-06 14:35:18 +0000
+++ src/Unity/resultsmodel.h	2016-02-16 08:14:59 +0000
@@ -44,8 +44,8 @@
     int rowCount(const QModelIndex& parent = QModelIndex()) const override;
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
-    void addResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>> const&);
-    void addUpdateResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>> const&);
+    void addResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>>&);
+    void addUpdateResults(QList<std::shared_ptr<unity::scopes::CategorisedResult>>&);
     void clearResults();
 
     /* getters */

=== modified file 'src/Unity/scope.cpp'
--- src/Unity/scope.cpp	2015-11-30 09:23:32 +0000
+++ src/Unity/scope.cpp	2016-02-16 08:14:59 +0000
@@ -595,11 +595,11 @@
         if (category_model == nullptr) {
             category_model.reset(new ResultsModel(m_categories.data()));
             category_model->setCategoryId(QString::fromStdString(category->id()));
-            category_model->addResults(m_category_results[category->id()]);
+            category_model->addResults(m_category_results[category->id()]); // de-duplicates m_category_results
             m_categories->registerCategory(category, category_model);
         } else {
             m_categories->registerCategory(category, QSharedPointer<ResultsModel>());
-            category_model->addUpdateResults(m_category_results[category->id()]);
+            category_model->addUpdateResults(m_category_results[category->id()]); // de-duplicates m_category_results
             m_categories->updateResultCount(category_model);
         }
     }

=== modified file 'tests/data/mock-scope-manyresults/mock-scope-manyresults.cpp'
--- tests/data/mock-scope-manyresults/mock-scope-manyresults.cpp	2015-10-12 14:48:41 +0000
+++ tests/data/mock-scope-manyresults/mock-scope-manyresults.cpp	2016-02-16 08:14:59 +0000
@@ -21,6 +21,8 @@
 
 #include <iostream>
 #include <thread>
+#include <cstdlib>
+#include <chrono>
 
 #define EXPORT __attribute__ ((visibility ("default")))
 
@@ -53,6 +55,21 @@
         auto cat1 = reply->register_category("cat1", "Category 1", "", meta_rndr);
         auto cat2 = reply->register_category("cat2", "Category 2", "", meta_rndr);
 
+        if (query_ == "")
+        {
+            // 2000 items
+            for (int i = 0; i<200; i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("cat1_uri" + std::to_string(i));
+                res.set_title("result5 for: \"" + query_ + "\"");
+                reply->push(res);
+
+                if (i % 100 == 0) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(40));
+                }
+            }
+        }
         if (query_ == "search1")
         {
             // five results with uris 0..4 in a single category cat1
@@ -114,7 +131,177 @@
                 reply->push(res);
             }
         }
-
+        else if (query_ == "lots_of_results")
+        {
+            // 2000 items
+            for (int i = 0; i<2000; i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("cat1_uri" + std::to_string(i));
+                res.set_title("result5 for: \"" + query_ + "\"");
+                reply->push(res);
+
+                if (i % 100 == 0) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(40));
+                }
+            }
+        }
+        else if (query_ == "lots_of_results_reversed")
+        {
+            // 2000 items, in the reversed order of search5
+            for (int i = 1999; i>=0; i--)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("cat1_uri" + std::to_string(i));
+                res.set_title("result5 for: \"" + query_ + "\"");
+                reply->push(res);
+
+                if (i % 100 == 0) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(40));
+                }
+            }
+        }
+        else if (query_ == "lots_of_results_reversed_plus_some")
+        {
+            // 2100 items, in the reversed order of search5, plus 100 extra results
+            for (int i = 2099; i>=0; i--)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("cat1_uri" + std::to_string(i));
+                res.set_title("result5 for: \"" + query_ + "\"");
+                reply->push(res);
+
+                if (i % 100 == 0) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(40));
+                }
+            }
+        }
+        else if (query_ == "lots_of_results_half_of_them_missing")
+        {
+            // 1000 items with uris matching every other item from previous search
+            for (int i = 0; i<1000; i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("cat1_uri" + std::to_string(i*2));
+                res.set_title("result5 for: \"" + query_ + "\"");
+                reply->push(res);
+
+                if (i % 100 == 0) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(40));
+                }
+            }
+        }
+        else if (query_ == "lots_of_results_2")
+        {
+            // 2000 items, all different than in previous searches
+            for (int i = 0; i<2000; i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("cat1_uri" + std::to_string(5000 + i));
+                res.set_title("result5 for: \"" + query_ + "\"");
+                reply->push(res);
+
+                if (i % 100 == 0) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(40));
+                }
+            }
+        }
+        else if (query_ == "lots_of_results_fast")
+        {
+            // 100 items
+            for (int i = 0; i<10; i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("cat1_uri" + std::to_string(i));
+                res.set_title("result5 for: \"" + query_ + "\"");
+                reply->push(res);
+            }
+        }
+        else if (query_ == "lots_of_results_reversed_fast")
+        {
+            // 100 items, in the reversed order of search5
+            for (int i = 9; i>=0; i--)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("cat1_uri" + std::to_string(i));
+                res.set_title("result5 for: \"" + query_ + "\"");
+                reply->push(res);
+            }
+        }
+        else if (query_ == "duplicated_uris1")
+        {
+            for (int i = 0; i<10; i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("uri");
+                res.set_title("result " + std::to_string(i));
+                reply->push(res);
+            }
+        }
+        else if (query_ == "duplicated_uris2")
+        {
+            for (int i = 0; i<10; i++)
+            {
+                CategorisedResult res(cat1);
+                if (i % 2 == 0) { // every other result uses same uri
+                    res.set_uri("uri");
+                } else {
+                    res.set_uri("uri" + std::to_string(i));
+                }
+                res.set_title("result " + std::to_string(i));
+                reply->push(res);
+            }
+        }
+        else if (query_ == "duplicated_results")
+        {
+            for (int i = 0; i<2; i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("uri");
+                res.set_title("result");
+                reply->push(res);
+            }
+        }
+        else if (query_ == "two-categories")
+        {
+            auto cat3 = reply->register_category("cat3", "Category 3", "", meta_rndr);
+            for (int i = 0; i<10; i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("uri" + std::to_string(i));
+                res.set_title("result " + std::to_string(i));
+                reply->push(res);
+
+                CategorisedResult res2(cat3);
+                res2.set_uri("uri" + std::to_string(i));
+                res2.set_title("result " + std::to_string(i));
+                reply->push(res2);
+            }
+        }
+        else if (query_ == "two-categories-second-gone")
+        {
+            for (int i = 0; i<10; i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("uri" + std::to_string(i));
+                res.set_title("result " + std::to_string(i));
+                reply->push(res);
+            }
+        }
+        else if (query_.find("random") == 0) // "random", followed by an int for the number of results
+        {
+            auto rand_start = rand() % 30;
+            for (int i = 0; i<std::stoi(query_.substr(6)); i++)
+            {
+                CategorisedResult res(cat1);
+                res.set_uri("cat1_uri" + std::to_string(rand_start + i));
+                res.set_title("result" + std::to_string(i));
+                reply->push(res);
+                if (i % 2 == 0) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(40));
+                }
+            }
+        }
     }
 
 private:

=== modified file 'tests/resultstest.cpp'
--- tests/resultstest.cpp	2015-10-12 15:42:50 +0000
+++ tests/resultstest.cpp	2016-02-16 08:14:59 +0000
@@ -22,7 +22,10 @@
 #include <QTimer>
 #include <QSignalSpy>
 #include <QDBusConnection>
+#include <QDebug>
 
+#include <chrono>
+#include <cstdlib>
 #include <Unity/resultsmodel.h>
 
 #include <unity/shell/scopes/CategoriesInterface.h>
@@ -97,6 +100,7 @@
     void initTestCase()
     {
         qputenv("UNITY_SCOPES_NO_WAIT_LOCATION", "1");
+        qputenv("UNITY_SCOPES_CARDINALITY_OVERRIDE", "9999");
         m_harness = sh::ScopeHarness::newFromScopeList(
             shr::CustomRegistry::Parameters({
                 TEST_DATA_DIR "mock-scope/mock-scope.ini",
@@ -1063,6 +1067,371 @@
                 .match(resultsView->categories())
         );
     }
+
+    void testResultsModelChangesWithDuplicatedUris()
+    {
+        auto resultsView = m_harness->resultsView();
+        resultsView->setActiveScope("mock-scope-manyresults");
+
+        // first search run
+        {
+            resultsView->setQuery("duplicated_uris1");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(10)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 10UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        QString::fromStdString("uri")
+                        );
+            }
+        }
+
+        // second search run
+        {
+            resultsView->setQuery("duplicated_uris2");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(10)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 10UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        (i % 2 == 0) ? QString::fromStdString("uri") : QString::fromStdString("uri" + std::to_string(i))
+                        );
+            }
+        }
+    }
+
+    void testResultsModelChangesWithDuplicatedResults()
+    {
+        auto resultsView = m_harness->resultsView();
+        resultsView->setActiveScope("mock-scope-manyresults");
+
+        {
+            resultsView->setQuery("duplicated_results");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(1)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 1UL);
+        }
+    }
+
+    void testResultsMassiveModelChanges()
+    {
+        auto resultsView = m_harness->resultsView();
+        resultsView->setActiveScope("mock-scope-manyresults");
+
+        // first search run
+        {
+            auto const start = std::chrono::system_clock::now();
+
+            resultsView->setQuery("lots_of_results");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(2000)
+                    )
+                    .match(resultsView->categories())
+            );
+            auto end = std::chrono::system_clock::now();
+            auto search_dur = std::chrono::duration_cast<std::chrono::seconds>(end.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::seconds>(start.time_since_epoch()).count();
+            qDebug() << "Search #1 duration: " << search_dur;
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 2000UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        QString::fromStdString("cat1_uri" + std::to_string(i))
+                        );
+            }
+        }
+
+        // second search run, reversed order of results
+        {
+            auto const start = std::chrono::system_clock::now();
+
+            resultsView->setQuery("lots_of_results_reversed_plus_some");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(2100)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const end = std::chrono::system_clock::now();
+            auto const search_dur = std::chrono::duration_cast<std::chrono::seconds>(end.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::seconds>(start.time_since_epoch()).count();
+            qDebug() << "Search #2 duration: " << search_dur;
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 2100UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        QString::fromStdString("cat1_uri" + std::to_string(2099-i))
+                        );
+            }
+        }
+
+        // second search run, reversed order of results
+        {
+            auto const start = std::chrono::system_clock::now();
+
+            resultsView->setQuery("lots_of_results_reversed");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(2000)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const end = std::chrono::system_clock::now();
+            auto const search_dur = std::chrono::duration_cast<std::chrono::seconds>(end.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::seconds>(start.time_since_epoch()).count();
+            qDebug() << "Search #3 duration: " << search_dur;
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 2000UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        QString::fromStdString("cat1_uri" + std::to_string(1999-i))
+                        );
+            }
+        }
+
+        // 1000 results, every other matches previous set
+        {
+            auto const start = std::chrono::system_clock::now();
+
+            resultsView->setQuery("lots_of_results_half_of_them_missing");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(1000)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const end = std::chrono::system_clock::now();
+            auto const search_dur = std::chrono::duration_cast<std::chrono::seconds>(end.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::seconds>(start.time_since_epoch()).count();
+            qDebug() << "Search #4 duration: " << search_dur;
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 1000UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        QString::fromStdString("cat1_uri" + std::to_string(i*2))
+                        );
+            }
+        }
+
+        // third search run, different result set
+        {
+            auto const start = std::chrono::system_clock::now();
+
+            resultsView->setQuery("lots_of_results_2");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(2000)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const end = std::chrono::system_clock::now();
+            auto const search_dur = std::chrono::duration_cast<std::chrono::seconds>(end.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::seconds>(start.time_since_epoch()).count();
+            qDebug() << "Search #5 duration: " << search_dur;
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 2000UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        QString::fromStdString("cat1_uri" + std::to_string(5000+i))
+                        );
+            }
+        }
+
+        // fourth search run, no delays in the scope
+        {
+            auto const start = std::chrono::system_clock::now();
+
+            resultsView->setQuery("lots_of_results_fast");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(10)
+                    )
+                    .match(resultsView->categories())
+            );
+            auto end = std::chrono::system_clock::now();
+            auto search_dur = std::chrono::duration_cast<std::chrono::seconds>(end.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::seconds>(start.time_since_epoch()).count();
+            qDebug() << "Search #6 duration: " << search_dur;
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 10UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        QString::fromStdString("cat1_uri" + std::to_string(i))
+                        );
+            }
+        }
+
+        // fifth search run, reversed order of results, no delays in the scope
+        {
+            auto const start = std::chrono::system_clock::now();
+
+            resultsView->setQuery("lots_of_results_reversed_fast");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(10)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const end = std::chrono::system_clock::now();
+            auto const search_dur = std::chrono::duration_cast<std::chrono::seconds>(end.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::seconds>(start.time_since_epoch()).count();
+            qDebug() << "Search #7 duration: " << search_dur;
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 10UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        QString::fromStdString("cat1_uri" + std::to_string(9-i))
+                        );
+            }
+        }
+        // search with empty string
+        {
+            auto const start = std::chrono::system_clock::now();
+
+            resultsView->setQuery("");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(200)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const end = std::chrono::system_clock::now();
+            auto const search_dur = std::chrono::duration_cast<std::chrono::seconds>(end.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::seconds>(start.time_since_epoch()).count();
+            qDebug() << "Search #8 duration: " << search_dur;
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), 200UL);
+            for (unsigned i = 0; i<results.size(); i++) {
+                QCOMPARE(
+                        QString::fromStdString(results[i].uri()),
+                        QString::fromStdString("cat1_uri" + std::to_string(i))
+                        );
+            }
+        }
+
+    }
+
+    void testResultsModelUpdatesRandomSearches()
+    {
+        // the aim of this test is to ensure no crashes; results art random and not verified
+        auto resultsView = m_harness->resultsView();
+        resultsView->setActiveScope("mock-scope-manyresults");
+
+        for (int i = 0; i<10; i++)
+        {
+            const unsigned long n = 1 + rand() % 100; // up to 100 results
+
+            resultsView->setQuery("random" + std::to_string(n));
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(n)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const results = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results.size()), n);
+        }
+    }
+
+    void testResultsModelUpdatesTwoCategories()
+    {
+        auto resultsView = m_harness->resultsView();
+        resultsView->setActiveScope("mock-scope-manyresults");
+
+        {
+            resultsView->setQuery("two-categories");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(2)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(10)
+                    )
+                    .category(shm::CategoryMatcher("cat3")
+                        .hasAtLeast(10)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const results1 = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results1.size()), 10UL);
+
+            auto const results2 = resultsView->category("cat3").results();
+            QCOMPARE(static_cast<unsigned long>(results2.size()), 10UL);
+        }
+        {
+            resultsView->setQuery("two-categories-second-gone");
+            QVERIFY_MATCHRESULT(
+                shm::CategoryListMatcher()
+                    .hasExactly(1)
+                    .category(shm::CategoryMatcher("cat1")
+                        .hasAtLeast(10)
+                    )
+                    .match(resultsView->categories())
+            );
+
+            auto const results1 = resultsView->category("cat1").results();
+            QCOMPARE(static_cast<unsigned long>(results1.size()), 10UL);
+        }
+    }
 };
 
 QTEST_GUILESS_MAIN(ResultsTest)