Merge lp:~gerboland/unity-mir/fix-upstart-closed-apps2 into lp:unity-mir/devel-mir-next

[Gerry Boland]

Refactoring to have app shutdown handled correctly.

Involves adding a canBeResumed flag to Application and using it to determine if AppMan should remove the application from the lists. Also add a big bunch of unit tests for AppMan.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:237
http://jenkins.qa.ubuntu.com/job/unity-mir-devel-ci/5/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-amd64-ci/5
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/5
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/5/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-i386-ci/5

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-devel-ci/5/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

Things to test:
1. start/stop apps (definitely include webbrowser and web apps)
2. Launch app with --desktop_file_hint and close it (a) with Ctrl+C, and (b) by stopping it in the UI
3. start/stop apps with upstart-app-launch/stop
4. start app from UI, then switch to another app/go to dash, then kill the process with "pkill -9 something" - app should remain in the running apps list. tapping it will eventually resume the app

[Michał Sawicz (saviq)]

Steps:
1. launch a webapp
2. go to dash
3. pkill -9 webapp
4. go to dash
5. pkill -9 webapp
6. app goes away

review: Needs Fixing

[Gerry Boland (gerboland)]

I'm not able to reproduce your bug. I've done the following:
1. launch gmail
2. return to dash
3. run kill -9 `pidof webapp-container`
Gmail still visible in dash
4. tap gmail running app preview
5. gmail eventually re-appears
6. GOTO 2.

Are you killing a child process of webapp-container maybe?

[Gerry Boland (gerboland)]

Update: gmail was a bad choice, as it is not a typical web app. Trying with other apps, can repro. Will fix

[lp:~gerboland/unity-mir/fix-upstart-closed-apps2]

238. By Gerry Boland on 2014-05-14

Fix webapps by disabling user-owned process shutdown detection

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:238
http://jenkins.qa.ubuntu.com/job/unity-mir-devel-ci/6/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-amd64-ci/6
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/6
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/6/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-i386-ci/6

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-devel-ci/6/rebuild

review: Approve (continuous-integration)

[Michał Sawicz (saviq)]

Weird behaviours:

$ webbrowser-app --desktop_file_hint=/usr/share/applications/webbrowser-app.desktop
→ go to dash
→ Ctrl+C
  → app remains in stack :|
→ tap on the app
→ gets restarted (outside of the console of course), with "webbrowser-app" as url?

$ webbrowser-app --desktop_file_hint=/usr/share/applications/
→ go to dash
→ Ctrl+C
  → app remains in stack :|
→ tap on the app
→ settings flashes, probably due to "webbrowser-app" as url?

→ launch settings
→ go into Accounts
→ press back and swipe to dash
→ empty "online accounts" in dash, disappears when tapped (probably can't be restarted)

I think if we special-case the if(false) for browser... only? We'd be good.

review: Needs Information

[Michał Sawicz (saviq)]

Ugh, the middle example is missing "ubuntu-system-settings.desktop" at the end of the command

[lp:~gerboland/unity-mir/fix-upstart-closed-apps2]

239. By Gerry Boland on 2014-05-16

Merge trunk

240. By Gerry Boland on 2014-05-19

Cmake tweak, mention mock header files as app dependency, so files appear in QtCreator

241. By Gerry Boland on 2014-05-19

Update tests against trunk

242. By Gerry Boland on 2014-05-19

Add "canBeResumed" state into Application, use to specify if AppMan must manage non-upstart started applications differently

[Gerry Boland (gerboland)]

Ok, think I've fixed those issues, please re-test

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:242
http://jenkins.qa.ubuntu.com/job/unity-mir-devel-ci/7/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-amd64-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/7
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/7/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-i386-ci/7

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-devel-ci/7/rebuild

review: Approve (continuous-integration)

[Michał Sawicz (saviq)]

Problem:
* $ upstart-app-launch webbrowser-app
* go to dash
* $ upstart app-stop webbrowser-app
* app remains in dash, where as you say it should go away

review: Needs Fixing

[Gerry Boland (gerboland)]

Hit meh

[lp:~gerboland/unity-mir/fix-upstart-closed-apps2]

243. By Gerry Boland on 2014-05-19

Logic refactoring to handle graceful app shutdown via upstart-app-stop

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:243
http://jenkins.qa.ubuntu.com/job/unity-mir-devel-ci/8/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-amd64-ci/8
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/8
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/8/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-i386-ci/8

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-devel-ci/8/rebuild

review: Approve (continuous-integration)

[Michał Sawicz (saviq)]

Two last issues I saw, probably not to fix in this branch anyway:
* when resuming apps, old app is focused until the new one launches
1. launch browser and another app
2. go to dash
3. $ pkill -9 webbrowser
4. tap on browser
5. the other app is focused before browser comes back in again

* when upstart-launching a focused app, animation is played
1. launch browser
2. $ upstart-app-launch webbrowser-app
3. browser animates on screen

[Gerry Boland (gerboland)]

> Two last issues I saw, probably not to fix in this branch anyway:
> * when resuming apps, old app is focused until the new one launches
> 1. launch browser and another app
> 2. go to dash
> 3. $ pkill -9 webbrowser
> 4. tap on browser
> 5. the other app is focused before browser comes back in again

Unable to fix with current architecture. Not a regression either I don't think.

> * when upstart-launching a focused app, animation is played
> 1. launch browser
> 2. $ upstart-app-launch webbrowser-app
> 3. browser animates on screen

unity8 bug I suspect, you see it also when flipping from gallery to camera using the in-app buttons. Also not regression

[Michał Sawicz (saviq)]

We should probably start thinking about generating coverage reports.

=====

 601 + // check application data
 602 + EXPECT_EQ(Application::Starting, theApp->state());
 603 + EXPECT_EQ(appId, theApp->appId());
 604 + EXPECT_EQ(name, theApp->name());
 605 + EXPECT_EQ(true, theApp->canBeResumed());
 606 +
 607 + // check signals were emitted
 608 + EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
 609 + EXPECT_EQ(applicationManager.count(), 1);
 610 + EXPECT_EQ(addedSpy.count(), 1);
 611 + EXPECT_EQ(addedSpy.takeFirst().at(0).toString(), appId);

Is there a reason why in the first set the expected value is the first arg while in the second set it's the second arg? I know this doesn't matter much, but is confusing TBH... You did this in most of the tests.

=====

 689 + bool authed = true;
 690 + applicationManager.authorizeSession(procId, authed);
 691 + EXPECT_EQ(authed, true);

Does Mir authorize sessions by default? I.e. is the bool true when passed to authorizeSession? Shouldn't we make it false to start with? Question valid for all the other places where you test this. Ah you actually do use = false in other places. Feels like we should consistently mimic what Mir does here. Or, alternatively, consistently require the call to change the value.

=====

All the FIXMEs for countSpy are about countChanged() emitted twice?

=====

 670 + QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
 671 + cmdLine = cmdLine.append(appId);

I'd probably flatten this, since you don't actually care about the value.

=====

 714 + const QString appId("testAppId");
 715 + const QString name("Test App");

Unused.

=====

 749 + const QString appId("testAppId");
 750 + const QString badDesktopFile = QString("%1.desktop").arg(appId);
 751 + quint64 procId = 5551;
 752 + QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
 753 + cmdLine = cmdLine.append(badDesktopFile);

Can be simplified, too - the value of badDesktopFile isn't actually important.

=====

 761 + ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(false));
 762 + ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));

Will this ever be called when loaded() returns false?

=====

You alternate between ON_CALL and EXPECT_CALL, WillByDefault and WillOnce, is there a reason why for the desktop reader you ignore whether / how many times it was called, while for procInfo you want them to be test fails when the unexpected happens?

=====

I wonder if procId randomness will mislead that the value has significance?

=====

 867 + * Test that an application in the Starting state is reacts correctly to the Mir sessionStarted

 911 + * Test that an application in the Starting state is reacts correctly to the Mir surfaceCreated

s/is reacts/reacts/

=====

 893 + std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("OO", procId);

 937 + std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("OO", procId);

Does "OO" have significance?

=====

 896 + bool authed = true;
 897 + applicationManager.authorizeSession(procId, authed);

Do we n...

review: Needs Information

[Michał Sawicz (saviq)]

1215 + * Test that if a background application is stopped by upstart, AppMan removes it from the app list
1216 + * as event result of direct user interaction

"as the result"?

=====

1317 + * Test that if a background application is reported to have stopped on startup by upstart
1318 + * This may be an upstart bug, or AppMan mis-understanging upstart's intentions. But need to check
1319 + * we're doing the right thing in either case. FIXME!

"by upstart", then?

review: Needs Information

[lp:~gerboland/unity-mir/fix-upstart-closed-apps2]

244. By Gerry Boland on 2014-05-20

Consistent arguments order for EXPET_EQ

245. By Gerry Boland on 2014-05-20

Surface name "OO" unnecessary, might confuse so removed

246. By Gerry Boland on 2014-05-20

"is reacts" -> "reacts"

247. By Gerry Boland on 2014-05-20

"as event result" -> "as the event is a result"

248. By Gerry Boland on 2014-05-20

Expand the explanation of the upstart "stopping while starting" workaround

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:244
http://jenkins.qa.ubuntu.com/job/unity-mir-devel-ci/11/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-amd64-ci/11
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/11
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/11/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-i386-ci/11

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-devel-ci/11/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

> We should probably start thinking about generating coverage reports.
True, l8r

> =====
> 601 + // check application data
> Is there a reason why in the first set the expected value is the first arg
> while in the second set it's the second arg? I know this doesn't matter much,
> but is confusing TBH... You did this in most of the tests.

Fixed

> =====

> 689 + bool authed = true;
> 690 + applicationManager.authorizeSession(procId, authed);
> 691 + EXPECT_EQ(authed, true);
>
> Does Mir authorize sessions by default? I.e. is the bool true when passed to
> authorizeSession? Shouldn't we make it false to start with? Question valid for
> all the other places where you test this. Ah you actually do use = false in
> other places. Feels like we should consistently mimic what Mir does here. Or,
> alternatively, consistently require the call to change the value.

It's a confusing API: "authed" is passed by reference, and set by authorizeSession. So it doesn't really matter what it is initialized to, what matters the decision authorizeSession makes.

We are emulating what Mir does here - for a client connecting to Mir, Mir calls this method, and if the returned value of authed is false, it rejects the client connection.

authorizeSession does set some internal state, so the step cannot be ignored.

> =====
> All the FIXMEs for countSpy are about countChanged() emitted twice?
Yep, I don't know why it's happening, would like to fix it.

> =====
>
> 670 + QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
> 671 + cmdLine = cmdLine.append(appId);
>
> I'd probably flatten this, since you don't actually care about the value.
It does, authorizeSession reads this line and parses the appId from the desktop, and then calls createInstance(appId,_).
>
> =====
>
> 714 + const QString appId("testAppId");
> 715 + const QString name("Test App");
> Unused.

They are used. The compiler would complain if they weren't.

> =====
>
> 749 + const QString appId("testAppId");
> 750 + const QString badDesktopFile = QString("%1.desktop").arg(appId);
> 751 + quint64 procId = 5551;
> 752 + QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
> 753 + cmdLine = cmdLine.append(badDesktopFile);
>
> Can be simplified, too - the value of badDesktopFile isn't actually important.
I'd prefer to keep this, as it's more realistically testing authorizeSession's CLI parsing.

> =====
> 761 + ON_CALL(*mockDesktopFileReader,
> loaded()).WillByDefault(Return(false));
> 762 + ON_CALL(*mockDesktopFileReader,
> appId()).WillByDefault(Return(appId));
>
> Will this ever be called when loaded() returns false?
Good catch, removed

> =====
> You alternate between ON_CALL and EXPECT_CALL, WillByDefault and WillOnce, is
> there a reason why for the desktop reader you ignore whether / how many times
> it was called, while for procInfo you want them to be test fails when the
> unexpected happens?

Because I don't really care how often the desktop file methods are called, only that they supply the correct info to AppManager do its thing. But things like procInfo do tie in closely with how AppManager works, so I wa...

[lp:~gerboland/unity-mir/fix-upstart-closed-apps2]

249. By Gerry Boland on 2014-05-20

Remove unneeded mock DesktopFileReader::appId() definition

[Michał Sawicz (saviq)]

 * Did you perform an exploratory manual test run of the code change and any related functionality?
Yes, tests pass and everything behaves as we want.

 * Did CI run pass? If not, please explain why.
Yes.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:249
http://jenkins.qa.ubuntu.com/job/unity-mir-devel-ci/12/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/12
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-armhf-ci/12/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-devel-utopic-i386-ci/12

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-devel-ci/12/rebuild

review: Approve (continuous-integration)

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-05-14 16:44:55 +0000
+++ src/modules/Unity/Application/application.cpp	2014-05-20 10:33:25 +0000
@@ -42,6 +42,7 @@
     , m_stage((m_desktopData->stageHint() == "SideStage") ? Application::SideStage : Application::MainStage)
     , m_state(state)
     , m_focused(false)
+    , m_canBeResumed(true)
     , m_fullscreen(false)
     , m_visible(false)
     , m_arguments(arguments)
@@ -142,6 +143,16 @@
     return m_visible;
 }
 
+bool Application::canBeResumed() const
+{
+    return m_canBeResumed;
+}
+
+void Application::setCanBeResumed(const bool resume)
+{
+    m_canBeResumed = resume;
+}
+
 pid_t Application::pid() const
 {
     return m_pid;

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2014-05-14 16:44:55 +0000
+++ src/modules/Unity/Application/application.h	2014-05-20 10:33:25 +0000
@@ -71,6 +71,9 @@
     QImage screenshotImage() const;
     void updateScreenshot();
 
+    bool canBeResumed() const;
+    void setCanBeResumed(const bool);
+
     bool isValid() const;
     QString desktopFile() const;
     QString exec() const;
@@ -106,6 +109,7 @@
     bool m_focused;
     QUrl m_screenshot;
     QImage m_screenshotImage;
+    bool m_canBeResumed;
     bool m_fullscreen;
     bool m_visible; // duplicating internal Mir data :(
     std::shared_ptr<::mir::scene::Session> m_session;
@@ -114,7 +118,6 @@
     QTimer* m_suspendTimer;
 
     friend class ApplicationManager;
-    friend class ApplicationListModel;
     friend class MirSurfaceManager;
 };
 

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2014-05-16 12:19:52 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-05-20 10:33:25 +0000
@@ -113,22 +113,22 @@
 {
     QObject::connect(strategy, &InitialSurfacePlacementStrategy::requestPlacementForSession,
                      manager, &ApplicationManager::placeSession, Qt::DirectConnection);
-
 }
 
 void connectToTaskController(ApplicationManager * manager, TaskController * controller)
 {
-    QObject::connect(controller, &TaskController::processStartReport,
-                     manager, &ApplicationManager::onProcessStartReportReceived);
+    QObject::connect(controller, &TaskController::processStarting,
+                     manager, &ApplicationManager::onProcessStarting);
     QObject::connect(controller, &TaskController::processStopped,
                      manager, &ApplicationManager::onProcessStopped);
+    QObject::connect(controller, &TaskController::processFailed,
+                     manager, &ApplicationManager::onProcessFailed);
     QObject::connect(controller, &TaskController::requestFocus,
                      manager, &ApplicationManager::onFocusRequested);
     QObject::connect(controller, &TaskController::requestResume,
                      manager, &ApplicationManager::onResumeRequested);
-
-}
-}
+}
+} // namespace
 
 ApplicationManager* ApplicationManager::Factory::Factory::create()
 {
@@ -485,20 +485,12 @@
     return application;
 }
 
-void ApplicationManager::onProcessStartReportReceived(const QString &appId, const bool failure)
+void ApplicationManager::onProcessStarting(const QString &appId)
 {
-    DLOG("ApplicationManager::onProcessStartReportReceived (this=%p, appId=%s, failure=%c)",
-         this, qPrintable(appId), (failure) ? 'Y' : 'N');
-
-    if (failure) {
-        DLOG("ApplicationManager::onProcessStartReportReceived handling failure:");
-        stopStartingApplication(appId);
-        return;
-    }
-
+    DLOG("ApplicationManager::onProcessStarting (this=%p, appId=%s)", this, qPrintable(appId));
     Application *application = findApplication(appId);
 
-    if (!application) { // if shell did not start this application, but upstart did
+    if (!application) { // then shell did not start this application, so upstart must have - add to list
         application = new Application(
                     m_taskController,
                     m_desktopFileReaderFactory->createInstance(appId, m_taskController->findDesktopFileForAppId(appId)),
@@ -519,6 +511,7 @@
         Q_EMIT focusRequested(appId);
     }
     else {
+<<<<<<< TREE
         DLOG("ApplicationManager::onProcessStartReportReceived application already found: (app=%p, appId=%s)", application, qPrintable(appId));
     }
 }
@@ -527,6 +520,46 @@
 {
     const QString appId = toShortAppIdIfPossible(inputAppId);
 
+=======
+        DLOG("ApplicationManager::onProcessStarting application already found: (app=%p, appId=%s)", application, qPrintable(appId));
+    }
+}
+
+void ApplicationManager::onProcessFailed(const QString &appId, const bool duringStartup)
+{
+    /* Applications fail if they fail to launch, crash or are killed. If failed to start, must
+     * immediately remove from list of applications. If crash or kill, instead we set flag on the
+     * Application to indicate it can be resumed.
+     */
+
+    DLOG("ApplicationManager::onProcessFailed (this=%p, appId=%s, duringStartup=%c)",
+         this, qPrintable(appId), (duringStartup) ? 'Y' : 'N');
+
+    Application *application = findApplication(appId);
+    if (!application) {
+        LOG("ApplicationManager::onProcessFailed - upstart reports failure of application AppManager is not managing");
+        return;
+    }
+
+    Q_UNUSED(duringStartup); // FIXME(greyback) upstart reports app that fully started up & crashes as failing during startup??
+    if (application->state() == Application::Starting) {
+        checkFocusOnRemovedApplication(application);
+        remove(application);
+        m_dbusWindowStack->WindowDestroyed(0, application->appId());
+        delete application;
+    } else {
+        // We need to set flags on the Application to say the app can be resumed, and thus should not be removed
+        // from the list by onProcessStopped.
+        application->setCanBeResumed(true);
+        application->setPid(0);
+    }
+}
+
+bool ApplicationManager::stopApplication(const QString &inputAppId)
+{
+    const QString appId = toShortAppIdIfPossible(inputAppId);
+
+>>>>>>> MERGE-SOURCE
     Application *application = findApplication(appId);
     DLOG("ApplicationManager::stopApplication (this=%p, application=%p, appId=%s)", this, application, qPrintable(appId));
 
@@ -574,55 +607,31 @@
     return true;
 }
 
-void ApplicationManager::stopStartingApplication(const QString &appId)
-{
-    Application *application = findApplication(appId);
-
-    if (application && application->state() == Application::Starting) {
-        shutdownApplication(application);
-    }
-    else if (application) {
-        DLOG("ApplicationManager::stopStartingApplication start failure report received - but application=%p, appId=%s is not in Starting state",application, qPrintable(appId));
-    }
-}
-
-void ApplicationManager::onProcessStopped(const QString &appId, const bool unexpected)
-{
-    Application *application = findApplication(appId);
+void ApplicationManager::onProcessStopped(const QString &appId)
+{
+    Application *application = findApplication(appId);
+    if (!application) {
+        DLOG("ApplicationManager::onProcessStopped reports stop of appId='%s' which AppMan is not managing, ignoring the event");
+        return;
+    }
     DLOG("ApplicationManager::onProcessStopped (this=%p, application=%p, appId=%s)", this, application, qPrintable(appId));
 
-    // if shell did not stop the application, but upstart says it died, we assume the process has been
-    // killed, so it can be respawned later. Only exception is if that application is focused or running
-    // as then it most likely crashed. Update this logic when upstart gives some failure info.
-    if (application) {
-        shutdownApplication(application);
-    }
-
-    if (unexpected) {
-        // TODO: pop up a message box/notification?
-        LOG("ApplicationManager: application '%s' died unexpectedly!", qPrintable(appId));
-    }
-}
-
-void ApplicationManager::shutdownApplication(Application* application)
-{
-    bool removeApplication = checkFocusOnRemovedApplication(application);
-
-    if (application->state() == Application::Running || application->state() == Application::Starting) {
-        // Application probably crashed, else OOM killer struck. Either way state wasn't saved
-        // so just remove application
-        removeApplication = true;
-    } else if (application->state() == Application::Suspended) {
-        application->setState(Application::Stopped);
-        application->setSession(nullptr);
+    bool removeApplication = true;
+
+    // The following scenario is the only time that we do NOT remove the application from the app list:
+    if ((application->state() == Application::Suspended || application->state() == Application::Stopped)
+            && application->pid() == 0 // i.e. onProcessFailed was called, which resets the PID of this application
+            && application->canBeResumed()) {
+        removeApplication = false;
     }
 
     if (removeApplication) {
+        DLOG("ApplicationManager::onProcessStopped - removing appId='%s' from the application list", qPrintable(appId));
+        checkFocusOnRemovedApplication(application);
         remove(application);
         m_dbusWindowStack->WindowDestroyed(0, application->appId());
         delete application;
     }
-
 }
 
 void ApplicationManager::onFocusRequested(const QString& appId)
@@ -644,7 +653,7 @@
     }
 
     // If app Stopped, trust that upstart-app-launch respawns it itself, and AppManager will
-    // be notified of that through the onProcessStartReportReceived slot. Else resume.
+    // be notified of that through the onProcessStarting slot. Else resume.
     if (application->state() == Application::Suspended) {
         application->setState(Application::Running);
     }
@@ -670,8 +679,6 @@
     }
 }
 
-/************************************* Mir-side methods *************************************/
-
 void ApplicationManager::authorizeSession(const quint64 pid, bool &authorized)
 {
     authorized = false; //to be proven wrong
@@ -761,6 +768,7 @@
     application = new Application(m_taskController, desktopData, Application::Starting, arguments, this);
     application->setPid(pid);
     application->setStage(stage);
+    application->setCanBeResumed(false);
     add(application);
     authorized = true;
 }
@@ -768,8 +776,8 @@
 void ApplicationManager::placeSession(ms::Session const* session, uint32_t &x, uint32_t &y)
 {
     Application* application = findApplicationWithSession(session);
-    DLOG("ApplicationManager::placeSession (this=%p, application=%p, session=%p, name=%s)", this, application, session, session?(session->name().c_str()):"null");
-    
+    DLOG("ApplicationManager::placeSession (this=%p, application=%p, session=%p, name=%s)", this, application, session,
+         session?(session->name().c_str()):"null");
 
     // Application defaults 
     x = 0;
@@ -818,32 +826,29 @@
     // in case application closed not by hand of shell, check again here:
     Application* application = findApplicationWithSession(session);
 
-    DLOG("ApplicationManager::onSessionStopping (this=%p, application=%p, appId=%s, session name=%s)", this, application, application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
+    DLOG("ApplicationManager::onSessionStopping (this=%p, application=%p, appId=%s, session name=%s)", this, application,
+         application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
 
     if (application) {
-        bool removeApplication = true;
-
-        if (application->state() != Application::Starting) {
-            application->setState(Application::Stopped);
-            application->setSession(nullptr);
+        /* Can remove the application from the running apps list immediately in these curcumstances:
+         *  1. application is not managed by upstart (this message from Mir is only notice the app has stopped, must do
+         *     it here)
+         *  2. application is managed by upstart, but has stopped before it managed to create a surface, we can assume
+         *     it crashed on startup, and thus cannot be resumed - so remove it.
+         *  3. application is managed by upstart and is in foreground (i.e. has Running state), if Mir reports the
+         *     application disconnects, it either crashed or stopped itself. Either case, remove it.
+         */
+        if (!application->canBeResumed()
+                || application->state() == Application::Starting
+                || application->state() == Application::Running) {
+            checkFocusOnRemovedApplication(application);
             m_dbusWindowStack->WindowDestroyed(0, application->appId());
-            if (application != m_focusedApplication) {
-                removeApplication = false;
-            }
-        }
-
-        if (m_mainStageApplication == application)
-            m_mainStageApplication = nullptr;
-        
-        if (m_sideStageApplication == application)
-            m_sideStageApplication = nullptr;
-
-        if (removeApplication) {
-            // TODO(greyback) What to do?? Focus next app, or unfocus everything??
-            m_focusedApplication = nullptr;
             remove(application);
             delete application;
-            Q_EMIT focusedApplicationIdChanged();
+        } else {
+            // otherwise, we do not have enough information to make any changes to the model, so await events from
+            // upstart to go further, but set the app state
+            application->setState(Application::Stopped);
         }
     }
 }
@@ -851,7 +856,8 @@
 void ApplicationManager::onSessionFocused(const std::shared_ptr<ms::Session>& session)
 {
     Application* application = findApplicationWithSession(session);
-    DLOG("ApplicationManager::onSessionFocused (this=%p, application=%p, appId=%s, session name=%s)", this, application, application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
+    DLOG("ApplicationManager::onSessionFocused (this=%p, application=%p, appId=%s, session name=%s)", this, application,
+         application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
 
     // Don't give application focus until it has created it's surface, when it is set as state "Running"
     // and only notify shell of focus changes that it actually expects

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2014-04-15 14:31:02 +0000
+++ src/modules/Unity/Application/application_manager.h	2014-05-20 10:33:25 +0000
@@ -125,8 +125,9 @@
 
     void onSessionCreatedSurface(::mir::scene::Session const*, std::shared_ptr<::mir::scene::Surface> const&);
 
-    void onProcessStartReportReceived(const QString& appId, const bool failure);
-    void onProcessStopped(const QString& appId, const bool unexpected);
+    void onProcessFailed(const QString& appId, const bool duringStartup);
+    void onProcessStarting(const QString& appId);
+    void onProcessStopped(const QString& appId);
     void onFocusRequested(const QString& appId);
     void onResumeRequested(const QString& appId);
 
@@ -144,9 +145,8 @@
     Application* findApplicationWithSession(const ::mir::scene::Session *session);
     Application* applicationForStage(Application::Stage stage);
     QModelIndex findIndex(Application* application);
-    bool checkFocusOnRemovedApplication(Application* application);
-    void shutdownApplication(Application* application);
-    void stopStartingApplication(const QString &appId);
+    bool isFocused(Application* application);
+    bool checkFocusOnRemovedApplication(Application *application);
 
     QList<Application*> m_applications;
     Application* m_focusedApplication; // remove as Mir has API for this

=== modified file 'src/modules/Unity/Application/taskcontroller.cpp'
--- src/modules/Unity/Application/taskcontroller.cpp	2014-05-12 11:09:42 +0000
+++ src/modules/Unity/Application/taskcontroller.cpp	2014-05-20 10:33:25 +0000
@@ -34,11 +34,8 @@
 // STL
 #include <mutex>
 
-// glib
-#include <glib.h>
-
 // std
-#include <signal.h>
+#include <csignal>
 #include <unistd.h>
 
 namespace unitymir
@@ -55,7 +52,7 @@
     connect(m_appController.data(),
             &ApplicationController::applicationAboutToBeStarted,
             this,
-            &TaskController::onApplicationAboutToBeStarted);
+            &TaskController::processStarting);
 
     connect(m_appController.data(),
             &ApplicationController::applicationStarted,
@@ -65,7 +62,7 @@
     connect(m_appController.data(),
             &ApplicationController::applicationStopped,
             this,
-            &TaskController::onApplicationStopped);
+            &TaskController::processStopped);
 
     connect(m_appController.data(),
             &ApplicationController::applicationFocusRequest,
@@ -146,22 +143,12 @@
     }
 }
 
-void TaskController::onApplicationAboutToBeStarted(const QString& id)
-{
-    Q_EMIT processStartReport(id, false);
-}
-
 void TaskController::onApplicationStarted(const QString& id)
 {
     pid_t pid = m_appController->primaryPidForAppId(id);
     m_processController->oomController()->ensureProcessUnlikelyToBeKilled(pid);
 }
 
-void TaskController::onApplicationStopped(const QString& id)
-{
-    Q_EMIT processStopped(id, false);
-}
-
 void TaskController::onApplicationFocusRequest(const QString& id)
 {
     pid_t pid = m_appController->primaryPidForAppId(id);
@@ -176,15 +163,7 @@
 
 void TaskController::onApplicationError(const QString& id, ApplicationController::Error error)
 {
-    switch(error)
-    {
-    case ApplicationController::Error::APPLICATION_CRASHED:
-        Q_EMIT processStopped(id, true);
-        break;
-    case ApplicationController::Error::APPLICATION_FAILED_TO_START:
-        Q_EMIT processStartReport(id, true);
-        break;
-    }
+    Q_EMIT processFailed(id, (error == ApplicationController::Error::APPLICATION_FAILED_TO_START) );
 
     // Is this really the signal we want to emit?
     Q_EMIT requestResume(id);

=== modified file 'src/modules/Unity/Application/taskcontroller.h'
--- src/modules/Unity/Application/taskcontroller.h	2014-05-12 11:09:42 +0000
+++ src/modules/Unity/Application/taskcontroller.h	2014-05-20 10:33:25 +0000
@@ -48,15 +48,14 @@
     QFileInfo findDesktopFileForAppId(const QString &appId) const;
 
 Q_SIGNALS:
-    void processStartReport(const QString& appId, const bool failure);
-    void processStopped(const QString& appId, const bool unexpectedly);
+    void processStarting(const QString& appId);
+    void processStopped(const QString& appId);
+    void processFailed(const QString& appId, const bool duringStartup);
     void requestFocus(const QString& appId);
     void requestResume(const QString& appId);
 
 private Q_SLOTS:
-    void onApplicationAboutToBeStarted(const QString& id);
     void onApplicationStarted(const QString& id);
-    void onApplicationStopped(const QString& id);
     void onApplicationFocusRequest(const QString& id);
     void onApplicationResumeRequest(const QString& id);
 

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-03-25 11:05:42 +0000
+++ tests/CMakeLists.txt	2014-05-20 10:33:25 +0000
@@ -24,14 +24,27 @@
   ${QT_TEST}
 )
 
+set(
+  MOCK_HEADERS
+  mock_application_controller.h
+  mock_desktop_file_reader.h
+  mock_focus_controller.h
+  mock_oom_controller.h
+  mock_process_controller.h
+  mock_proc_info.h
+  mock_session.h
+)
+
 add_executable(
   application_manager_test
   application_manager_test.cpp
+  ${MOCK_HEADERS}
 )
 
 add_executable(
   taskcontroller_test
   taskcontroller_test.cpp
+  ${MOCK_HEADERS}
 )
 
 # We should not need this line according to the Qt5/CMake docs.

=== modified file 'tests/application_manager_test.cpp'
--- tests/application_manager_test.cpp	2014-05-13 17:23:22 +0000
+++ tests/application_manager_test.cpp	2014-05-20 10:33:25 +0000
@@ -45,18 +45,22 @@
             QSharedPointer<ProcessController::OomController> (
                 &oomController,
                 [](ProcessController::OomController*){})
-        },
-        applicationManager{
-            QSharedPointer<TaskController>{
-                new TaskController(
-                    nullptr,
-                    QSharedPointer<ApplicationController>(
-                        &appController,
-                        [](ApplicationController*){}),
-                    QSharedPointer<ProcessController>(
-                        &processController,
-                        [](ProcessController*){})
-                    )},
+        }
+        , taskController{
+              QSharedPointer<TaskController> (
+                  new TaskController(
+                      nullptr,
+                      QSharedPointer<ApplicationController>(
+                          &appController,
+                          [](ApplicationController*){}),
+                      QSharedPointer<ProcessController>(
+                          &processController,
+                          [](ProcessController*){})
+                  )
+              )
+        }
+        , applicationManager{
+            taskController,
             QSharedPointer<DesktopFileReader::Factory>(
                 &desktopFileReaderFactory,
                 [](DesktopFileReader::Factory*){}),
@@ -72,6 +76,7 @@
     testing::NiceMock<testing::MockProcInfo> procInfo;
     testing::NiceMock<testing::MockDesktopFileReaderFactory> desktopFileReaderFactory;
     testing::NiceMock<testing::MockFocusController> focusController;
+    QSharedPointer<TaskController> taskController;
     ApplicationManager applicationManager;
 };
 
@@ -167,7 +172,7 @@
 
     // now a second session without desktop file is launched:
     applicationManager.authorizeSession(secondProcId, authed);
-    applicationManager.onProcessStartReportReceived(dialer_app_id, true);
+    applicationManager.onProcessStarting(dialer_app_id);
 
     EXPECT_EQ(false,authed);
     EXPECT_EQ(app,applicationManager.findApplication(dialer_app_id));
@@ -191,7 +196,8 @@
     applicationManager.authorizeSession(procId, authed);
     applicationManager.onSessionStarting(mirSession);
     Application * beforeFailure = applicationManager.findApplication(app_id);
-    applicationManager.onProcessStartReportReceived(app_id,true);
+    applicationManager.onProcessStarting(app_id);
+    applicationManager.onProcessFailed(app_id, true);
     Application * afterFailure = applicationManager.findApplication(app_id);
 
     EXPECT_EQ(true, authed);
@@ -218,7 +224,8 @@
     applicationManager.onSessionStarting(mirSession);
     Application * beforeFailure = applicationManager.findApplication(app_id);
     applicationManager.onSessionCreatedSurface(mirSession.get(), aSurface);
-    applicationManager.onProcessStartReportReceived(app_id, true);
+    applicationManager.onProcessStarting(app_id);
+    applicationManager.onProcessFailed(app_id, false);
     Application * afterFailure = applicationManager.findApplication(app_id);
 
     EXPECT_EQ(true, authed);
@@ -394,7 +401,7 @@
     ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
 
     // mock upstart launching an app which reports itself as sidestage, but we're on phone
-    applicationManager.onProcessStartReportReceived(appId, false);
+    applicationManager.onProcessStarting(appId);
 
     // ensure the app stage is overridden to be main stage
     Application* theApp = applicationManager.findApplication(appId);
@@ -513,3 +520,1276 @@
     QList<QVariant> arguments = spy.takeFirst(); // take the first signal
     EXPECT_EQ(arguments.at(0).toString(), "app3");
 }
+
+/*
+ * Test that an application launched by shell itself creates the correct Application instance and
+ * emits signals indicating the model updated
+ */
+TEST_F(ApplicationManagerTests,appStartedByShell)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString name("Test App");
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+    ON_CALL(*mockDesktopFileReader, name()).WillByDefault(Return(name));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    // start the application
+    Application *theApp = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+
+    // check application data
+    EXPECT_EQ(theApp->state(), Application::Starting);
+    EXPECT_EQ(theApp->appId(), appId);
+    EXPECT_EQ(theApp->name(), name);
+    EXPECT_EQ(theApp->canBeResumed(), true);
+
+    // check signals were emitted
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(addedSpy.count(), 1);
+    EXPECT_EQ(addedSpy.takeFirst().at(0).toString(), appId);
+
+    // check application in list of apps
+    Application *theAppAgain = applicationManager.findApplication(appId);
+    EXPECT_EQ(theAppAgain, theApp);
+}
+
+/*
+ * Test that an application launched upstart (i.e. not by shell itself) creates the correct Application
+ * instance and emits signals indicating the model updated
+ */
+TEST_F(ApplicationManagerTests,appStartedByUpstart)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString name("Test App");
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+    ON_CALL(*mockDesktopFileReader, name()).WillByDefault(Return(name));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusRequested(const QString &)));
+
+    // upstart sends notification that the application was started
+    applicationManager.onProcessStarting(appId);
+
+    Application *theApp = applicationManager.findApplication(appId);
+
+    // check application data
+    EXPECT_EQ(theApp->state(), Application::Starting);
+    EXPECT_EQ(theApp->appId(), appId);
+    EXPECT_EQ(theApp->name(), name);
+    EXPECT_EQ(theApp->canBeResumed(), true);
+
+    // check signals were emitted
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(addedSpy.count(), 1);
+    EXPECT_EQ(addedSpy.takeFirst().at(0).toString(), appId);
+    EXPECT_EQ(focusSpy.count(), 1);
+    EXPECT_EQ(focusSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that an application launched via the command line with a correct --desktop_file_hint is accepted,
+ * creates the correct Application instance and emits signals indicating the model updated
+ */
+TEST_F(ApplicationManagerTests,appStartedUsingCorrectDesktopFileHintSwitch)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString name("Test App");
+    quint64 procId = 5551;
+    QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
+    cmdLine = cmdLine.append(appId);
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+    ON_CALL(*mockDesktopFileReader, name()).WillByDefault(Return(name));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    // Mir requests authentication for an application that was started
+    bool authed = false;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+
+    Application *theApp = applicationManager.findApplication(appId);
+
+    // check application data
+    EXPECT_EQ(theApp->state(), Application::Starting);
+    EXPECT_EQ(theApp->appId(), appId);
+    EXPECT_EQ(theApp->name(), name);
+    EXPECT_EQ(theApp->canBeResumed(), false);
+
+    // check signals were emitted
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(addedSpy.count(), 1);
+    EXPECT_EQ(addedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that an application launched via the command line without the correct --desktop_file_hint is rejected
+ */
+TEST_F(ApplicationManagerTests,appDoesNotStartWhenUsingBadDesktopFileHintSwitch)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString name("Test App");
+    quint64 procId = 5551;
+    QByteArray cmdLine("/usr/bin/testApp");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    // Mir requests authentication for an application that was started
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, false);
+
+    Application *theApp = applicationManager.findApplication(appId);
+
+    EXPECT_EQ(theApp, nullptr);
+
+    // check no new signals were emitted
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(addedSpy.count(), 0);
+}
+
+/*
+ * Test that an application launched via the command line with the --desktop_file_hint but an incorrect
+ * desktop file specified is rejected
+ */
+TEST_F(ApplicationManagerTests,appDoesNotStartWhenUsingBadDesktopFileHintFile)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString badDesktopFile = QString("%1.desktop").arg(appId);
+    quint64 procId = 5551;
+    QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
+    cmdLine = cmdLine.append(badDesktopFile);
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(false));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    // Mir requests authentication for an application that was started, should fail
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, false);
+}
+
+/*
+ * Test that the child sessions of a webapp process are accepted
+ */
+TEST_F(ApplicationManagerTests,webAppSecondarySessionsAccepted)
+{
+    using namespace ::testing;
+    quint64 procId = 5551;
+    QByteArray cmdLine("/usr/bin/qt5/libexec/QtWebProcess");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+}
+
+/*
+ * Test that signon-ui sessions are accepted
+ */
+TEST_F(ApplicationManagerTests,signonUiSessionsAccepted)
+{
+    using namespace ::testing;
+    quint64 procId = 5151;
+    QByteArray cmdLine("/usr/bin/signon-ui --blah=http://signon-ui");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+}
+
+/*
+ * Test that maliit sessions are accepted
+ */
+TEST_F(ApplicationManagerTests,maliitSessionsAccepted)
+{
+    using namespace ::testing;
+    quint64 procId = 151;
+    QByteArray cmdLine("maliit-server --blah");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+}
+
+/*
+ * Test that an application in the Starting state is not impacted by the upstart "Starting" message
+ * for that application (i.e. the upstart message is effectively useless)
+ */
+TEST_F(ApplicationManagerTests,onceAppAddedToApplicationLists_upstartStartingEventIgnored)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    // upstart sends notification that the application was started
+    applicationManager.onProcessStarting(appId);
+
+    // check no new signals were emitted and application state unchanged
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(addedSpy.count(), 0);
+
+    Application *theApp = applicationManager.findApplication(appId);
+    EXPECT_EQ(Application::Starting, theApp->state());
+}
+
+/*
+ * Test that an application in the Starting state reacts correctly to the Mir sessionStarted
+ * event for that application (i.e. the Session is associated)
+ */
+TEST_F(ApplicationManagerTests,onceAppAddedToApplicationLists_mirSessionStartingEventHandled)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+
+    // Authorize session and emit Mir sessionStarting event
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(addedSpy.count(), 0);
+
+    // Check application state and session are correctly set
+    Application *theApp = applicationManager.findApplication(appId);
+    EXPECT_EQ(theApp->session(), session);
+    EXPECT_EQ(theApp->focused(), false);
+}
+
+/*
+ * Test that an application in the Starting state reacts correctly to the Mir surfaceCreated
+ * event for that application (i.e. the Surface is associated and state set to Running)
+ */
+TEST_F(ApplicationManagerTests,onceAppAddedToApplicationLists_mirSurfaceCreatedEventHandled)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+
+    QSignalSpy dataSpy(&applicationManager, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
+    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
+
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+
+    EXPECT_EQ(dataSpy.count(), 1);
+    EXPECT_EQ(focusSpy.count(), 1);
+
+    // Check application state is correctly set
+    Application *theApp = applicationManager.findApplication(appId);
+    EXPECT_EQ(theApp->state(), Application::Running);
+    EXPECT_EQ(theApp->focused(), true);
+
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+}
+
+/*
+ * Test that an application is stopped correctly, if it has not yet created a surface (still in Starting state)
+ */
+TEST_F(ApplicationManagerTests,shellStopsAppCorrectlyBeforeSurfaceCreated)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Stop app
+    applicationManager.stopApplication(appId);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that the foreground application is stopped correctly (is in Running state, has surface)
+ */
+TEST_F(ApplicationManagerTests,shellStopsForegroundAppCorrectly)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Stop app
+    applicationManager.stopApplication(appId);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that the background application is stopped correctly
+ */
+TEST_F(ApplicationManagerTests,shellStopsBackgroundAppCorrectly)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Stop app
+    applicationManager.stopApplication(appId);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that if an application is stopped by upstart, before it has created a surface, AppMan cleans up after it ok
+ */
+TEST_F(ApplicationManagerTests,upstartNotificationOfStartingAppBeingStopped)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Upstart notifies of stopping app
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that if the foreground Running application is stopped by upstart, AppMan cleans up after it ok
+ */
+TEST_F(ApplicationManagerTests,upstartNotifiesOfStoppingForegroundApp)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Upstart notifies of stopping app
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that if the foreground Running application is reported to unexpectedly stop by upstart, AppMan
+ * cleans up after it ok (as was not in background, had not lifecycle saved its state, so cannot be resumed)
+ */
+TEST_F(ApplicationManagerTests,upstartNotifiesOfUnexpectedStopOfForegroundApp)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Upstart notifies of crashing / OOM killed app
+    applicationManager.onProcessFailed(appId, false);
+
+    // Upstart finally notifies the app stopped
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that if a background application is stopped by upstart, AppMan removes it from the app list
+ * as the event is a result of direct user interaction
+ */
+TEST_F(ApplicationManagerTests,upstartNotifiesOfStoppingBackgroundApp)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Upstart notifies of stopping app
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(focusSpy.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that if a background application is reported to unexpectedly stop by upstart, AppMan does not remove
+ * it from the app lists but instead considers it Stopped, ready to be resumed. This is due to the fact the
+ * app should have saved its state, so can be resumed. This situation can occur due to the OOM killer, or
+ * a dodgy app crashing.
+ */
+TEST_F(ApplicationManagerTests,unexpectedStopOfBackgroundApp)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir reports disconnection
+    applicationManager.onSessionStopping(session);
+
+    // Upstart notifies of crashing / OOM-killed app
+    applicationManager.onProcessFailed(appId, false);
+
+    EXPECT_EQ(focusSpy.count(), 0);
+
+    // Upstart finally notifies the app stopped
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(removedSpy.count(), 0);
+}
+
+/*
+ * Test that if a background application is reported to have stopped on startup by upstart, that it
+ * is kept in the application model, as the app can be lifecycle resumed.
+ *
+ * Note that upstart reports this "stopped on startup" even for applications which are running.
+ * This may be an upstart bug, or AppMan mis-understanding upstart's intentions. But need to check
+ * we're doing the right thing in either case. CHECKME(greyback)!
+ */
+TEST_F(ApplicationManagerTests,unexpectedStopOfBackgroundAppCheckingUpstartBug)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir reports disconnection
+    applicationManager.onSessionStopping(session);
+
+    // Upstart notifies of crashing app
+    applicationManager.onProcessFailed(appId, true);
+
+    EXPECT_EQ(focusSpy.count(), 0);
+
+    // Upstart finally notifies the app stopped
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(removedSpy.count(), 0);
+}
+
+/*
+ * Test that if a Starting application is then reported to be stopping by Mir, AppMan cleans up after it ok
+ */
+TEST_F(ApplicationManagerTests,mirNotifiesStartingAppIsNowStopping)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.onSessionStopping(session);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that if a Running foreground application is reported to be stopping by Mir, AppMan cleans up after it ok
+ */
+TEST_F(ApplicationManagerTests,mirNotifiesOfStoppingForegroundApp)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    // Associate a surface so AppMan considers app Running, check focused
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.onSessionStopping(session);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that if a foreground application (one launched via desktop_file_hint) is reported to be stopping by
+ * Mir, AppMan removes it from the model immediately
+ */
+TEST_F(ApplicationManagerTests,mirNotifiesOfStoppingForegroundAppLaunchedWithDesktopFileHint)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString name("Test App");
+    quint64 procId = 5551;
+    QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
+    cmdLine = cmdLine.append(appId);
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+    ON_CALL(*mockDesktopFileReader, name()).WillByDefault(Return(name));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    // Mir requests authentication for an application that was started
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    applicationManager.onSessionStarting(session);
+
+    // Associate a surface so AppMan considers app Running, check focused
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.onSessionStopping(session);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+
+    Application *app = applicationManager.findApplication(appId);
+    EXPECT_EQ(nullptr, app);
+}
+
+/*
+ * Test that if a background application is reported to be stopping by Mir, AppMan sets its state to Stopped
+ * but does not remove it from the model
+ */
+TEST_F(ApplicationManagerTests,mirNotifiesOfStoppingBackgroundApp)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    // Associate a surface so AppMan considers app Running, check in background
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.onSessionStopping(session);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(removedSpy.count(), 0);
+
+    Application * app = applicationManager.findApplication(appId);
+    EXPECT_NE(nullptr,app);
+    EXPECT_EQ(app->state(), Application::Stopped);
+}
+
+/*
+ * Test that if a background application (one launched via desktop_file_hint) is reported to be stopping by
+ * Mir, AppMan removes it from the model immediately
+ */
+TEST_F(ApplicationManagerTests,mirNotifiesOfStoppingBackgroundAppLaunchedWithDesktopFileHint)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString name("Test App");
+    quint64 procId = 5551;
+    QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
+    cmdLine = cmdLine.append(appId);
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+    ON_CALL(*mockDesktopFileReader, name()).WillByDefault(Return(name));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    // Mir requests authentication for an application that was started
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    applicationManager.onSessionStarting(session);
+
+    // Associate a surface so AppMan considers app Running, check in background
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.onSessionStopping(session);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+
+    Application * app = applicationManager.findApplication(appId);
+    EXPECT_EQ(nullptr,app);
+}
+
+/*
+ * Test that when an application is stopped correctly by shell, the upstart stopping event is ignored
+ */
+TEST_F(ApplicationManagerTests,shellStoppedApp_upstartStoppingEventIgnored)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    applicationManager.stopApplication(appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Upstart notifies of stopping app
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 0);
+}
+
+/*
+ * Test that when an application is stopped correctly by shell, the Mir Session stopped event is ignored
+ */
+TEST_F(ApplicationManagerTests,shellStoppedApp_mirSessionStoppingEventIgnored)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    applicationManager.stopApplication(appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app/Session
+    applicationManager.onSessionStopping(session);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 0);
+}
+
+/*
+ * Test that if an application is stopped by upstart, the Mir stopping event is ignored
+ */
+TEST_F(ApplicationManagerTests,appStoppedByUpstart_mirSessionStoppingEventIgnored)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    applicationManager.onProcessStopped(appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.onSessionStopping(session);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 0);
+}
+
+/*
+ * Webapps have multiple sessions, but only one is linked to the application (other is considered a hidden session).
+ * If webapp in foreground stops unexpectedly, remove it and it alone from app list
+ */
+TEST_F(ApplicationManagerTests,unexpectedStopOfForegroundWebapp)
+{
+    using namespace ::testing;
+    const QString appId("webapp");
+    quint64 procId1 = 5551;
+    quint64 procId2 = 5564;
+    QByteArray cmdLine("/usr/bin/qt5/libexec/QtWebProcess");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId2))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    ON_CALL(appController,appIdHasProcessId(procId1, appId)).WillByDefault(Return(true));
+    ON_CALL(appController,appIdHasProcessId(procId2, _)).WillByDefault(Return(false));
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session1 = std::make_shared<MockSession>("", procId1);
+    std::shared_ptr<mir::scene::Session> session2 = std::make_shared<MockSession>("", procId2);
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId1, authed);
+    applicationManager.onSessionStarting(session1);
+    EXPECT_EQ(authed, true);
+    applicationManager.authorizeSession(procId2, authed);
+    applicationManager.onSessionStarting(session2);
+    EXPECT_EQ(authed, true);
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session2.get(), surface);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app/Session
+    applicationManager.onSessionStopping(session2);
+    applicationManager.onSessionStopping(session1);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Webapps have multiple sessions, but only one is linked to the application (other is considered a hidden session).
+ * If webapp in background stops unexpectedly, do not remove it from app list
+ */
+TEST_F(ApplicationManagerTests,unexpectedStopOfBackgroundWebapp)
+{
+    using namespace ::testing;
+    const QString appId("webapp");
+    quint64 procId1 = 5551;
+    quint64 procId2 = 5564;
+    QByteArray cmdLine("/usr/bin/qt5/libexec/QtWebProcess");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId2))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    ON_CALL(appController,appIdHasProcessId(procId1, appId)).WillByDefault(Return(true));
+    ON_CALL(appController,appIdHasProcessId(procId2, _)).WillByDefault(Return(false));
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session1 = std::make_shared<MockSession>("", procId1);
+    std::shared_ptr<mir::scene::Session> session2 = std::make_shared<MockSession>("", procId2);
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId1, authed);
+    applicationManager.onSessionStarting(session1);
+    EXPECT_EQ(authed, true);
+    applicationManager.authorizeSession(procId2, authed);
+    applicationManager.onSessionStarting(session2);
+    EXPECT_EQ(authed, true);
+
+    // both sessions create surfaces, then unfocus everything.
+    std::shared_ptr<mir::scene::Surface> surface1(nullptr);
+    applicationManager.onSessionCreatedSurface(session1.get(), surface1);
+    std::shared_ptr<mir::scene::Surface> surface2(nullptr);
+    applicationManager.onSessionCreatedSurface(session2.get(), surface2);
+    applicationManager.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app/Session
+    applicationManager.onSessionStopping(session2);
+    applicationManager.onSessionStopping(session1);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 0);
+}

=== modified file 'tests/mock_session.h'
--- tests/mock_session.h	2014-04-15 14:31:02 +0000
+++ tests/mock_session.h	2014-05-20 10:33:25 +0000
@@ -15,8 +15,8 @@
  *
  */
 
-#ifndef MOCK_MIR_SHELL_SESSION_H
-#define MOCK_MIR_SHELL_SESSION_H
+#ifndef MOCK_MIR_SCENE_SESSION_H
+#define MOCK_MIR_SCENE_SESSION_H
 
 #include <mir/scene/session.h>
 #include <mir/graphics/display_configuration.h>
@@ -66,4 +66,4 @@
 };
 }
 
-#endif // MOCK_MIR_SHELL_SESSION_H
+#endif // MOCK_MIR_SCENE_SESSION_H