Merge lp:~saviq/unity-api/add-shell-notifications-api into lp:unity-api

[Michał Sawicz]

add shell Notifications API and tests

[Michał Sawicz (saviq)]

This will fail due to Qt in headers, we need somehow to whitelist Qt for the shell interface.

[lp:~saviq/unity-api/add-shell-notifications-api]

40. By Michał Sawicz on 2013-05-13

merge fix-packaging

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:40
http://jenkins.qa.ubuntu.com/job/unity-api-ci/5/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-i386-ci/5/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/5/rebuild

review: Needs Fixing (continuous-integration)

[Michi Henning (michihenning)]

A few minor nitpicks due to style issues (https://launchpad.net/canonical-client-development-guidelines and https://wiki.ubuntu.com/DesktopTeam/Specs/CPlusPlusGuide):

In source.h:

#include SOURCE_H

should be

#include UNITY_SHELL_NOTIFICATIONS_SOURCE_H

The include guard should include the namespace hierarchy.

This affects enums.h, model.h, and notification.h as well.

- In source.h (and other headers):

namespace unity {
namespace shell {
namespace notifications {

The style guide requires braces to go on their own line. For readability, I would suggest to add a newline:

namespace unity
{

namespace shell
{

namespace notifications
{

- I don't want to get into religious wars about placement of curly braces. (Personally, I can live with either K&R style or braces on separate lines.) But it would be really nice if we could be consistent at least. For example, testutil.cpp uses K&R style but elsewhere in the project, we have braces on separate lines. (The style guide suggests braces on separate lines, if only by example.)

The easiest thing might be to just run astyle over the source?

- For a class called TestUtilPlugin, please call the source/header files TestUtilPlugin.h and TestUtilPlugin.cpp, so we have consistent spelling everywhere. Similarly, model.h should be called ModelInterface.h, seeing that it only defines that one class. (The same comment applies throughout, such as for the files underneath test/mocks.)

- We have mocks/plugins/Unity/Notifications, but the corresponding namespaces are called "unity" and "notifications". Therefore, the corresponding directories also should be called "unity" and "notifications"?

review: Needs Fixing

[lp:~saviq/unity-api/add-shell-notifications-api]

41. By Michał Sawicz on 2013-05-14

merge add-qmltest-utils

42. By Michał Sawicz on 2013-05-14

fix c++ and naming style

43. By Michał Sawicz on 2013-05-14

merge add-qmltest-utils

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:43
http://jenkins.qa.ubuntu.com/job/unity-api-ci/12/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/12/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-i386-ci/12/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/12/rebuild

review: Needs Fixing (continuous-integration)

[Michał Sawicz (saviq)]

W dniu 14.05.2013 03:20, Michi Henning pisze:
> should be
>
> #include UNITY_SHELL_NOTIFICATIONS_SOURCE_H
>
> The include guard should include the namespace hierarchy.
>
> This affects enums.h, model.h, and notification.h as well.

Done.

> - In source.h (and other headers):
>
> namespace unity {
> namespace shell {
> namespace notifications {
>
> The style guide requires braces to go on their own line. For readability, I would suggest to add a newline:
>
> namespace unity
> {
>
> namespace shell
> {
>
> namespace notifications
> {
>
> - I don't want to get into religious wars about placement of curly braces. (Personally, I can live with either K&R style or braces on separate lines.) But it would be really nice if we could be consistent at least. For example, testutil.cpp uses K&R style but elsewhere in the project, we have braces on separate lines. (The style guide suggests braces on separate lines, if only by example.)
>
> The easiest thing might be to just run astyle over the source?

I must say IMO it reduces readability, but style is style - done.

> - For a class called TestUtilPlugin, please call the source/header files TestUtilPlugin.h and TestUtilPlugin.cpp, so we have consistent spelling everywhere. Similarly, model.h should be called ModelInterface.h, seeing that it only defines that one class. (The same comment applies throughout, such as for the files underneath test/mocks.)

Done.

> - We have mocks/plugins/Unity/Notifications, but the corresponding namespaces are called "unity" and "notifications". Therefore, the corresponding directories also should be called "unity" and "notifications"?

The "Unity/Notifications" part is not directly corresponding to the
namespaces (at least not QML ones). "import Unity.Notifications 0.1" in
QML means "look for a plugin under
$QML2_IMPORT_PATH/Unity/Notifications". We need to keep the import names
CamelCase (although we might need to move them under org/ubuntu/ to
comply with Qt recommendations) for consistency in QML. We would have to
do some hoops to keep them lowercase in the tree but build into CamelCase.

I'm just thinking things under "imports", "plugins", "modules" are
QML-specific and should just reflect the actual QML import path.

--
Michał Sawicz <email address hidden>
Canonical Services Ltd.

[Michi Henning (michihenning)]

> Done.

Thanks!

> > - We have mocks/plugins/Unity/Notifications, but the corresponding
> namespaces are called "unity" and "notifications". Therefore, the
> corresponding directories also should be called "unity" and "notifications"?
>
> The "Unity/Notifications" part is not directly corresponding to the
> namespaces (at least not QML ones). "import Unity.Notifications 0.1" in
> QML means "look for a plugin under
> $QML2_IMPORT_PATH/Unity/Notifications". We need to keep the import names
> CamelCase (although we might need to move them under org/ubuntu/ to
> comply with Qt recommendations) for consistency in QML. We would have to
> do some hoops to keep them lowercase in the tree but build into CamelCase.

I suspected that this was due to a Qt issue, so I guess we just have to live with that. (The style guide requires namespace names to be lower case--I have no idea why. But, as you say, style is style...)

> I'm just thinking things under "imports", "plugins", "modules" are
> QML-specific and should just reflect the actual QML import path.

Sounds sensible to me!

review: Approve

[lp:~saviq/unity-api/add-shell-notifications-api]

44. By Michał Sawicz on 2013-05-15

merge add-testutil-module

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:44
http://jenkins.qa.ubuntu.com/job/unity-api-ci/18/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/18/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-i386-ci/18/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/18/rebuild

review: Needs Fixing (continuous-integration)

[lp:~saviq/unity-api/add-shell-notifications-api]

45. By Michał Sawicz on 2013-05-15

merge add-qmltest-util

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:45
http://jenkins.qa.ubuntu.com/job/unity-api-ci/20/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/20/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-i386-ci/20/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/20/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:45
http://jenkins.qa.ubuntu.com/job/unity-api-ci/21/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/21/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-i386-ci/21/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/21/rebuild

review: Needs Fixing (continuous-integration)

[lp:~saviq/unity-api/add-shell-notifications-api]

46. By Michał Sawicz on 2013-05-15

send hovered and displayed values to onHovered / onDisplayed and add documentation

47. By Michał Sawicz on 2013-05-15

convert the slots to signals to ensure asynchronicity

[Michał Sawicz (saviq)]

OK, this now has docs as well.

Should be good for review/merging after lp:~michihenning/unity-api/improve-include-checker lands.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:47
http://jenkins.qa.ubuntu.com/job/unity-api-ci/22/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/22/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-api-raring-i386-ci/22/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/22/rebuild

review: Needs Fixing (continuous-integration)

[Michi Henning (michihenning)]

> OK, this now has docs as well.
>
> Should be good for review/merging after lp:~michihenning/unity-api/improve-
> include-checker lands.

For classes that only have signals (NotificationInterface) and, therefore, don't have pure virtual functions, should the constructor be protected to prevent instantiation of the abstract base class?

Some minor doc fixes here:

https://pastebin.canonical.com/91076/

review: Needs Fixing

[Michi Henning (michihenning)]

One more thing: "make cppcheck" reports one function that is never called (see below). The tests should exercise it, I would think?

For those functions that we truly don't want to exercise (any?), an inline suppression can be used, such as:

void
// cppcheck-suppress unusedFunction
Myclass::
foo()
{
}

I'll submit a separate MR to change the way cppcheck is called to include the name of the error in the output, so it's easy to add a suppression if we need one.

$ make cppcheck
/home/michi/src/add-shell-notifications-api/test/mocks/plugins/Unity/Notifications/Mocks/MockActionModel.cpp ( 36 ) : style ( unusedFunction ) : The function 'rowCount' is never used.
Built target cppcheck

review: Needs Fixing

[lp:~saviq/unity-api/add-shell-notifications-api]

48. By Michał Sawicz on 2013-05-16

merge add-qmltest-util

49. By Michał Sawicz on 2013-05-16

merge trunk

50. By Michał Sawicz on 2013-05-16

add cppcheck suppression to MockActionModel::rowCount

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:50
http://jenkins.qa.ubuntu.com/job/unity-api-ci/29/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/29
        deb: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/29/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-api-raring-i386-ci/29

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/29/rebuild

review: Approve (continuous-integration)

[lp:~saviq/unity-api/add-shell-notifications-api]

51. By Michi Henning on 2013-05-16

doc fixes

52. By Michał Sawicz on 2013-05-16

Protect NotificationInterface constructor and tweak doxygen comments

[Michał Sawicz (saviq)]

W dniu 16.05.2013 01:41, Michi Henning pisze:
> For classes that only have signals (NotificationInterface) and, therefore, don't have pure virtual functions, should the constructor be protected to prevent instantiation of the abstract base class?

Indeed. Fixed. Should the others (SourceInterface, ModelInterface)
follow the same, even though it's not necessary due to pure virtuals?

> One more thing: "make cppcheck" reports one function that is never called (see below). The tests should exercise it, I would think?

They do, actually - but indirectly - it's used internally by QML in
tst_Notificaions.qml. That's probably why cppcheck thinks otherwise?

> I'll submit a separate MR to change the way cppcheck is called to include the name of the error in the output, so it's easy to add a suppression if we need one.

I resubmitted it without the prerequisite because of conflicts and will
merge when CI says it's fine.
--
Michał Sawicz <email address hidden>
Canonical Services Ltd.

[Michał Sawicz (saviq)]

W dniu 16.05.2013 10:01, Michał Sawicz pisze:
> Indeed. Fixed. Should the others (SourceInterface, ModelInterface)
> follow the same, even though it's not necessary due to pure virtuals?

What about pure virtual destructors? Should we make them so, too?

--
Michał Sawicz <email address hidden>
Canonical Services Ltd.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:52
http://jenkins.qa.ubuntu.com/job/unity-api-ci/31/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/31
        deb: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/31/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-api-raring-i386-ci/31

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/31/rebuild

review: Approve (continuous-integration)

[Michi Henning (michihenning)]

> W dniu 16.05.2013 10:01, Michał Sawicz pisze:
> > Indeed. Fixed. Should the others (SourceInterface, ModelInterface)
> > follow the same, even though it's not necessary due to pure virtuals?

For self-documentation purposes and clarity, it makes sense to make all the constructors protected, even if there are pure virtual methods elsewhere in the class.

> What about pure virtual destructors? Should we make them so, too?

No. Destructors should to remain public. There really is no point making the destructor in a base class protected. It would prevent stack allocation of the class (if it were not abstract). But, seeing the class is abstract already, there is no point in a protected destructor.

[Michi Henning (michihenning)]

> > One more thing: "make cppcheck" reports one function that is never called
> (see below). The tests should exercise it, I would think?
>
> They do, actually - but indirectly - it's used internally by QML in
> tst_Notificaions.qml. That's probably why cppcheck thinks otherwise?

Looks like it's fine now. Not sure why I saw this error even after I added builddir/test to cppcheck. Never mind. If this pops up again, we can deal with it separately.

> I resubmitted it without the prerequisite because of conflicts and will
> merge when CI says it's fine.

Thanks!

review: Approve

[Michał Sawicz (saviq)]

W dniu 16.05.2013 10:54, Michi Henning pisze:
> Looks like it's fine now. Not sure why I saw this error even after I added builddir/test to cppcheck. Never mind. If this pops up again, we can deal with it separately.

That's because I've added cppcheck-suppress for it...

> For self-documentation purposes and clarity, it makes sense to make all the constructors protected, even if there are pure virtual methods elsewhere in the class.

Yup, that's what I thought. Will do.

> No. Destructors should to remain public. There really is no point making the destructor in a base class protected. It would prevent stack allocation of the class (if it were not abstract). But, seeing the class is abstract already, there is no point in a protected destructor.

No no, I meant whether we should make them pure virtual - they're not,
currently.

--
Michał Sawicz <email address hidden>
Canonical Services Ltd.

[lp:~saviq/unity-api/add-shell-notifications-api]

53. By Michał Sawicz on 2013-05-16

protect ModelInterface and SourceInterface c'tors, too

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:53
http://jenkins.qa.ubuntu.com/job/unity-api-ci/32/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/32
        deb: http://jenkins.qa.ubuntu.com/job/unity-api-raring-armhf-ci/32/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-api-raring-i386-ci/32

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/32/rebuild

review: Approve (continuous-integration)

[Michi Henning (michihenning)]

> No no, I meant whether we should make them pure virtual - they're not,
> currently.

Ah, I see :-)

Hmmm... Pure virtual destructors are rarely used, if ever. They are a bit of a pain because you also need to write an out-of-line definition for a pure virtual destructor. (That's because the destructor *will* be called, despite being pure, so there has to be an implementation.)

Overall, I don't see any additional benefit. I guess it would make the class even more self-documenting. On the other hand, I doubt that the average C++ programmer would even know what a pure virtual destructor means...

Basically, the issue only arises for classes that are abstract and have at least one non-pure virtual function. In that case, making the constructor protected is effective. Making the destructor pure virtual is also effective. Doing both is effective as well, but one of the two is redudant.

If a class is abstract and does *not* have any virtual functions, then the only way to make it abstract is with a pure virtual destructor. But then, one has to ask the question "what's the point of an abstract base class that does not have a single virtual functions?" As far as I can see, there is none. In effect, such a class says "you must not instantiate me directly, but only via a derived class. The derived class is not obliged to do anything in particular, but it must have at least one virtual function. I don't care what that function is called or what it does." I simply can't see a use case for this...

Now, someone tell me again, why does C++ not have an abstract keyword so I could just write

abstract class X { ... }

So, overall, I'd be inclined to say there is no need for pure virtual destructor, but I don't feel all that strongly about it. The class is correct whether the destructor is pure virtual or just virtual.

[Michał Sawicz (saviq)]

W dniu 16.05.2013 12:52, Michi Henning pisze:
> So, overall, I'd be inclined to say there is no need for pure virtual destructor, but I don't feel all that strongly about it. The class is correct whether the destructor is pure virtual or just virtual.

Cool!

OK so the only remaining thing might be the cppcheck suppression - shall
I leave it in or do we want to investigate why it's wrongly marked as
unused?
--
Michał Sawicz <email address hidden>
Canonical Services Ltd.

[Michi Henning (michihenning)]

> OK so the only remaining thing might be the cppcheck suppression - shall
> I leave it in or do we want to investigate why it's wrongly marked as
> unused?

After doing a build and running

find . -name '*.cpp' | xargs egrep rowCount

from the top directory, I get only two hits, one in MockActionModel.cpp, and one in MockModel.cpp. Both are definitions of the method.

The complaint from cppcheck is for the one in MockActionModel.cpp. What's strange is that, despite there being no call site for either of them in any .cpp or .h file, we get a complaint for only one of them. I would have expected two complaints for this, one for each definition.

At any rate, I'm happy to let this go. It's probably not worth the effort of tracking down what's going on here.

review: Approve

=== added directory 'data'
=== added file 'data/unity-shell-api.pc.in'
--- data/unity-shell-api.pc.in	1970-01-01 00:00:00 +0000
+++ data/unity-shell-api.pc.in	2013-05-16 10:27:27 +0000
@@ -0,0 +1,9 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+includedir=${prefix}/include
+
+Name: @PKGCONFIG_NAME@
+Description: @PKGCONFIG_NAME@
+Version: @VERSION@
+
+Requires: @PKGCONFIG_REQUIRES@
+Cflags: -I${includedir}

=== modified file 'debian/libunity-api-dev.install'
--- debian/libunity-api-dev.install	2013-05-16 10:27:26 +0000
+++ debian/libunity-api-dev.install	2013-05-16 10:27:27 +0000
@@ -1,3 +1,3 @@
 usr/include/unity/*
 usr/lib/*/libunity-api.so
-usr/lib/*/pkgconfig/libunity-api.pc
+usr/lib/*/pkgconfig/*.pc

=== modified file 'doc/Doxyfile.in'
--- doc/Doxyfile.in	2013-05-13 11:39:49 +0000
+++ doc/Doxyfile.in	2013-05-16 10:27:27 +0000
@@ -203,7 +203,7 @@
 # will result in a user-defined paragraph with heading "Side Effects:".
 # You can put \n's in the value part of an alias to insert newlines.
 
-ALIASES                =
+ALIASES                = "accessors=\par Accessors:\n" "notifier=\par Notifier:\n"
 
 # This tag can be used to specify a number of word-keyword mappings (TCL only).
 # A mapping has the form "name=value". For example adding

=== modified file 'include/unity/CMakeLists.txt'
--- include/unity/CMakeLists.txt	2013-05-15 02:05:18 +0000
+++ include/unity/CMakeLists.txt	2013-05-16 10:27:27 +0000
@@ -1,4 +1,5 @@
 add_subdirectory(api)
+add_subdirectory(shell)
 add_subdirectory(util)
 
 file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h")

=== added directory 'include/unity/shell'
=== added file 'include/unity/shell/CMakeLists.txt'
--- include/unity/shell/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ include/unity/shell/CMakeLists.txt	2013-05-16 10:27:27 +0000
@@ -0,0 +1,8 @@
+add_subdirectory(notifications)
+
+file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
+file(GLOB internal_headers "${CMAKE_CURRENT_SOURCE_DIR}/internal/*.h")
+
+install(FILES ${headers} DESTINATION ${HDR_INSTALL_DIR}/unity/shell)
+
+set(UNITY_API_LIB_HDRS ${UNITY_API_LIB_HDRS} ${headers} ${internal_headers} PARENT_SCOPE)

=== added directory 'include/unity/shell/notifications'
=== added file 'include/unity/shell/notifications/CMakeLists.txt'
--- include/unity/shell/notifications/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ include/unity/shell/notifications/CMakeLists.txt	2013-05-16 10:27:27 +0000
@@ -0,0 +1,22 @@
+set(INCLUDE_INSTALL_DIR include/unity/shell/notifications)
+
+file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
+file(GLOB internal_headers "${CMAKE_CURRENT_SOURCE_DIR}/internal/*.h")
+
+install(FILES ${headers} DESTINATION ${INCLUDE_INSTALL_DIR})
+
+set(UNITY_API_LIB_HDRS ${UNITY_API_LIB_HDRS} ${headers} ${internal_headers} PARENT_SCOPE)
+
+set(VERSION 1)
+set(PKGCONFIG_NAME "unity-shell-notifications")
+set(PKGCONFIG_DESCRIPTION "Unity shell Notifications APIs")
+set(PKGCONFIG_REQUIRES "Qt5Core")
+set(PKGCONFIG_FILE unity-shell-notifications.pc)
+
+configure_file(${CMAKE_SOURCE_DIR}/data/unity-shell-api.pc.in
+  ${CMAKE_BINARY_DIR}/data/${PKGCONFIG_FILE} @ONLY
+)
+
+install(FILES ${CMAKE_BINARY_DIR}/data/${PKGCONFIG_FILE}
+  DESTINATION ${LIB_INSTALL_PREFIX}/pkgconfig
+)

=== added file 'include/unity/shell/notifications/Enums.h'
--- include/unity/shell/notifications/Enums.h	1970-01-01 00:00:00 +0000
+++ include/unity/shell/notifications/Enums.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef UNITY_SHELL_NOTIFICATIONS_ENUMS_H
+#define UNITY_SHELL_NOTIFICATIONS_ENUMS_H
+
+#include <unity/config.h>
+
+#include <QtCore/QObject>
+
+namespace unity
+{
+
+namespace shell
+{
+
+namespace notifications
+{
+
+/**
+\brief Wraps NotificationInterface's urgency enumeration.
+*/
+
+class UNITY_API Urgency : public QObject
+{
+    Q_OBJECT
+
+    Q_ENUMS(UrgencyEnum)
+
+public:
+    /**
+    \brief NotificationInterface's urgency enumeration.
+
+    This determines the order in which notifications are displayed.
+    */
+    enum class UrgencyEnum
+    {
+        Invalid = 0,
+        Low,            /**< Displayed last. */
+        Normal,         /**< Displayed before Low, after Critical. */
+        Critical        /**< Displayed before Low and Normal. */
+    };
+};
+
+
+/**
+\brief Wraps NotificationInterface's type enumeration.
+*/
+
+class UNITY_API Type : public QObject
+{
+    Q_OBJECT
+
+    Q_ENUMS(TypeEnum)
+
+public:
+    /**
+    \brief NotificationInterface's type enumeration.
+
+    This determines the visual and interaction behavior of the displayed notification.
+    */
+    enum class TypeEnum
+    {
+        Invalid = 0,
+        Confirmation,   /**< Confirmation (synchronous). */
+        Ephemeral,      /**< Ephemeral (input-transparent). */
+        Interactive,    /**< Interactive (clickable). */
+        SnapDecision,   /**< Snap decision (multi-button). */
+        Placeholder     /**< Non-visible placeholder of default size. */
+    };
+};
+
+
+/**
+\brief Wraps NotificationInterface's hint flags.
+*/
+
+class UNITY_API Hint : public QObject
+{
+    Q_OBJECT
+
+    Q_FLAGS(HintEnum)
+
+public:
+    /**
+    \brief NotificationInterface's hint flags.
+
+    This modifies some visual and interactive behavior of the displayed notification.
+    */
+    enum HintEnum
+    {
+        Invalid    = 1 << 0,
+        ButtonTint = 1 << 1,    /**< Use a colour tint on the positive button in a snap decision. */
+        IconOnly   = 1 << 2     /**< Only display the icon, no summary or body. */
+    };
+
+    Q_DECLARE_FLAGS(Hints, HintEnum)
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(Hint::Hints)
+
+} // namespace notifications
+
+} // namespace shell
+
+} // namespace unity
+
+#endif // UNITY_SHELL_NOTIFICATIONS_ENUMS_H

=== added file 'include/unity/shell/notifications/ModelInterface.h'
--- include/unity/shell/notifications/ModelInterface.h	1970-01-01 00:00:00 +0000
+++ include/unity/shell/notifications/ModelInterface.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef UNITY_SHELL_NOTIFICATIONS_MODELINTERFACE_H
+#define UNITY_SHELL_NOTIFICATIONS_MODELINTERFACE_H
+
+#include <unity/config.h>
+
+#include <QtCore/QAbstractListModel>
+
+namespace unity
+{
+
+namespace shell
+{
+
+namespace notifications
+{
+
+
+/**
+\brief A list of notifications to be displayed
+
+This model exposes all the notifications that are currently supposed to be on screen.
+Not all of them might actually get on screen due to screen size, in which case the
+NotificationInterface::displayed() signal will only be emitted after the notification was
+actually displayed.
+*/
+
+class UNITY_API ModelInterface : public QAbstractListModel
+{
+    Q_OBJECT
+
+    /**
+    \brief Whether a placeholder for confirmation should be kept at the beginning
+
+    When this is true, the model should hold a Placeholder type notification at the top
+    and update its data when an incoming Confirmation type notification is sent.
+
+    \accessors %confirmationPlaceholder(), setConfirmationPlaceholder(bool confirmationPlaceholder)
+    \notifier confirmationPlaceholderChanged(bool confirmationPlaceholder)
+    */
+    Q_PROPERTY(bool confirmationPlaceholder READ confirmationPlaceholder WRITE setConfirmationPlaceholder NOTIFY confirmationPlaceholderChanged)
+
+protected:
+    /// @cond
+    explicit ModelInterface(QObject* parent = 0) : QAbstractListModel(parent) { }
+    /// @endcond
+
+public:
+    virtual ~ModelInterface() { }
+
+    /// @cond
+    virtual bool confirmationPlaceholder() const = 0;
+    virtual void setConfirmationPlaceholder(bool confirmationPlaceholder) = 0;
+    /// @endcond
+
+Q_SIGNALS:
+    /**
+    Emitted when value of the confirmationPlaceholder property has changed.
+
+    \param confirmationPlaceholder New value of the confirmationPlaceholder property.
+    */
+    void confirmationPlaceholderChanged(bool confirmationPlaceholder);
+};
+
+} // namespace notifications
+
+} // namespace shell
+
+} // namespace unity
+
+#endif // UNITY_SHELL_NOTIFICATIONS_MODELINTERFACE_H

=== added file 'include/unity/shell/notifications/NotificationInterface.h'
--- include/unity/shell/notifications/NotificationInterface.h	1970-01-01 00:00:00 +0000
+++ include/unity/shell/notifications/NotificationInterface.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef UNITY_SHELL_NOTIFICATIONS_NOTIFICATIONINTERFACE_H
+#define UNITY_SHELL_NOTIFICATIONS_NOTIFICATIONINTERFACE_H
+
+#include <unity/config.h>
+
+#include <QtCore/QObject>
+
+namespace unity
+{
+
+namespace shell
+{
+
+namespace notifications
+{
+
+/**
+\brief A Notification object
+
+This class exposes signals used by the UI to communicate the state
+of a notification.
+*/
+
+class UNITY_API NotificationInterface : public QObject
+{
+    Q_OBJECT
+
+protected:
+    /// @cond
+    explicit NotificationInterface(QObject* parent = 0) : QObject(parent) { }
+    /// @endcond
+
+public:
+    virtual ~NotificationInterface() { }
+
+Q_SIGNALS:
+    /**
+    Will be called whenever the mouse hover status of a notification changes.
+
+    \param hovered Mouse hover status of this notification.
+    */
+    void hovered(bool hovered);
+
+    /**
+    Will be called whenever the display status of a notification changes.
+
+    \param displayed Visible/hidden status of this notification.
+    */
+    void displayed(bool displayed);
+
+    /**
+    Will be called whenever the notification was dismissed. This can be called internally
+    by the notification implementation (e.g. timeout) or from the UI when the user dismisses
+    a notification.
+    */
+    void dismissed();
+
+    /**
+    Will be called whenever an action of this notification is to be invoked.
+
+    \param id Id of the invoked action.
+    */
+    void actionInvoked(const QString& id);
+};
+
+} // namespace notifications
+
+} // namespace shell
+
+} // namespace unity
+
+#endif // UNITY_SHELL_NOTIFICATIONS_NOTIFICATIONINTERFACE_H

=== added file 'include/unity/shell/notifications/SourceInterface.h'
--- include/unity/shell/notifications/SourceInterface.h	1970-01-01 00:00:00 +0000
+++ include/unity/shell/notifications/SourceInterface.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef UNITY_SHELL_NOTIFICATIONS_SOURCEINTERFACE_H
+#define UNITY_SHELL_NOTIFICATIONS_SOURCEINTERFACE_H
+
+#include <unity/config.h>
+
+#include <QtCore/QObject>
+
+namespace unity
+{
+
+namespace shell
+{
+
+namespace notifications
+{
+
+
+class ModelInterface;
+
+/**
+\brief A source of notifications
+
+This should feed the model with new notifications from an implementation-specific
+source.
+*/
+class UNITY_API SourceInterface : public QObject
+{
+    Q_OBJECT
+
+    /**
+    \brief The model to which to send incoming notifications.
+
+    \accessors %model(), setModel(ModelInterface* model)
+    \notifier modelChanged(ModelInterface* model)
+    */
+    Q_PROPERTY(unity::shell::notifications::ModelInterface* model READ model WRITE setModel NOTIFY modelChanged)
+
+protected:
+    /// @cond
+    explicit SourceInterface(QObject* parent = 0) : QObject(parent) { }
+    /// @endcond
+
+public:
+    virtual ~SourceInterface() { }
+
+    /// @cond
+    virtual ModelInterface* model() const = 0;
+    virtual void setModel(ModelInterface* model) = 0;
+    /// @endcond
+
+Q_SIGNALS:
+    /**
+    Emitted when value of the model property has changed.
+
+    \param model New value of the model property.
+    */
+    void modelChanged(ModelInterface* model);
+};
+
+} // namespace notifications
+
+} // namespace shell
+
+} // namespace unity
+
+#endif // UNITY_SHELL_NOTIFICATIONS_SOURCEINTERFACE_H

=== modified file 'test/qmltest/CMakeLists.txt'
--- test/qmltest/CMakeLists.txt	2013-05-16 10:27:26 +0000
+++ test/qmltest/CMakeLists.txt	2013-05-16 10:27:27 +0000
@@ -1,1 +1,3 @@
 add_subdirectory(modules)
+add_subdirectory(mocks)
+add_subdirectory(unity)

=== added directory 'test/qmltest/mocks'
=== added file 'test/qmltest/mocks/CMakeLists.txt'
--- test/qmltest/mocks/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/CMakeLists.txt	2013-05-16 10:27:27 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(plugins/Unity/Notifications)

=== added directory 'test/qmltest/mocks/plugins'
=== added directory 'test/qmltest/mocks/plugins/Unity'
=== added directory 'test/qmltest/mocks/plugins/Unity/Notifications'
=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/CMakeLists.txt'
--- test/qmltest/mocks/plugins/Unity/Notifications/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/CMakeLists.txt	2013-05-16 10:27:27 +0000
@@ -0,0 +1,41 @@
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_definitions(-DQT_NO_KEYWORDS)
+set(CMAKE_AUTOMOC ON)
+
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Quick REQUIRED)
+
+set(NotificationsMocks_SOURCES
+    ${CMAKE_SOURCE_DIR}/include/unity/shell/notifications/Enums.h
+    ${CMAKE_SOURCE_DIR}/include/unity/shell/notifications/ModelInterface.h
+    ${CMAKE_SOURCE_DIR}/include/unity/shell/notifications/SourceInterface.h
+    ${CMAKE_SOURCE_DIR}/include/unity/shell/notifications/NotificationInterface.h
+    Mocks/MockModel.cpp
+    Mocks/MockSource.cpp
+    Mocks/MockNotification.cpp
+    Mocks/MockActionModel.cpp
+)
+
+add_library(NotificationsMocks SHARED ${NotificationsMocks_SOURCES})
+
+qt5_use_modules(NotificationsMocks Core)
+
+set(TestNotificationsPlugin_SOURCES
+    TestNotificationsPlugin.cpp
+)
+
+add_library(TestNotificationsPlugin MODULE ${TestNotificationsPlugin_SOURCES})
+
+qt5_use_modules(TestNotificationsPlugin Core Quick)
+
+target_link_libraries(TestNotificationsPlugin NotificationsMocks)
+
+add_custom_target(TestNotificationsPluginQmldir ALL
+    COMMAND cp "${CMAKE_CURRENT_SOURCE_DIR}/qmldir" "${CMAKE_CURRENT_BINARY_DIR}"
+    DEPENDS qmldir
+)
+
+add_subdirectory(Mocks)

=== added directory 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks'
=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/CMakeLists.txt'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/CMakeLists.txt	2013-05-16 10:27:27 +0000
@@ -0,0 +1,14 @@
+set(MockNotificationsPlugin_SOURCES
+    MockNotificationsPlugin.cpp
+)
+
+add_library(MockNotificationsPlugin MODULE ${MockNotificationsPlugin_SOURCES})
+
+qt5_use_modules(MockNotificationsPlugin Core Quick)
+
+target_link_libraries(MockNotificationsPlugin NotificationsMocks)
+
+add_custom_target(MockNotificationsPluginQmldir ALL
+    COMMAND cp "${CMAKE_CURRENT_SOURCE_DIR}/qmldir" "${CMAKE_CURRENT_BINARY_DIR}"
+    DEPENDS qmldir
+)

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockActionModel.cpp'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockActionModel.cpp	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockActionModel.cpp	2013-05-16 10:27:27 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#include <Mocks/MockActionModel.h>
+#include <Mocks/MockNotification.h>
+
+#include <QtCore/QVariantList>
+#include <QtCore/QVariantMap>
+
+MockActionModel::MockActionModel(QObject* parent)
+    : QAbstractListModel(parent)
+    , m_notification(qobject_cast<MockNotification*>(parent))
+{
+    m_roles.insert(Label, "label");
+    m_roles.insert(Id, "id");
+}
+
+int
+// cppcheck-suppress unusedFunction
+MockActionModel::rowCount(const QModelIndex& /* parent */) const
+{
+    if (m_notification && m_notification->m_data.contains("actions"))
+    {
+        QVariantList actions = m_notification->m_data["actions"].value<QVariantList>();
+        return actions.count();
+    }
+    return 0;
+}
+
+QVariant
+MockActionModel::data(const QModelIndex &index, int role) const
+{
+    QVariantMap action = m_notification->m_data["actions"].value<QVariantList>()[index.row()].value<QVariantMap>();
+    if (role == Label)
+    {
+        return action["label"];
+    }
+    else if (role == Id)
+    {
+        return action["id"];
+    }
+    else
+    {
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray>
+MockActionModel::roleNames() const
+{
+    return m_roles;
+}

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockActionModel.h'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockActionModel.h	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockActionModel.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef MOCKACTIONMODEL_H
+#define MOCKACTIONMODEL_H
+
+#include <unity/config.h>
+
+#include <QtCore/QAbstractListModel>
+
+class MockNotification;
+
+class UNITY_API MockActionModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    Q_ENUMS(RoleEnum)
+public:
+    explicit MockActionModel(QObject *parent = 0);
+
+    int rowCount(const QModelIndex& parent) const;
+    QVariant data(const QModelIndex &index, int role) const;
+    QHash<int, QByteArray> roleNames() const;
+
+    enum RoleEnum
+    {
+        Label = Qt::DisplayRole,
+        Id = Qt::UserRole
+    };
+
+private:
+    QHash<int, QByteArray> m_roles;
+    MockNotification* m_notification;
+};
+
+Q_DECLARE_METATYPE(MockActionModel*)
+
+#endif // MOCKACTIONMODEL_H

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockModel.cpp'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockModel.cpp	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockModel.cpp	2013-05-16 10:27:27 +0000
@@ -0,0 +1,215 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#include <Mocks/MockModel.h>
+#include <Mocks/MockNotification.h>
+#include <Mocks/MockActionModel.h>
+
+#include <unity/shell/notifications/Enums.h>
+#include <unity/shell/notifications/SourceInterface.h>
+#include <unity/shell/notifications/NotificationInterface.h>
+
+#include <QtCore/QUrl>
+
+using namespace unity::shell::notifications;
+
+MockModel::MockModel(QObject* parent)
+    : ModelInterface(parent)
+{
+    m_roles.insert(Summary, "summary");
+    m_roles.insert(Notification, "notification");
+    m_roles.insert(Id, "id");
+    m_roles.insert(Type, "type");
+    m_roles.insert(Urgency, "urgency");
+    m_roles.insert(Body, "body");
+    m_roles.insert(Value, "value");
+    m_roles.insert(Icon, "icon");
+    m_roles.insert(SecondaryIcon, "secondaryIcon");
+    m_roles.insert(Hints, "hints");
+    m_roles.insert(Actions, "actions");
+}
+
+int
+MockModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+
+    return m_list.count();
+}
+
+QVariant
+MockModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid())
+    {
+        return QVariant();
+    }
+
+    MockNotification* notification = m_list.at(index.row());
+
+    if (role == Summary)
+    {
+        return QVariant("");
+    }
+    else if (role == Notification)
+    {
+        return QVariant::fromValue(notification);
+    }
+    else if (role == Id)
+    {
+        return QVariant(index.row());
+    }
+    else if (role == Type)
+    {
+        if (notification->m_data.contains("type"))
+        {
+            return notification->m_data["type"];
+        }
+        else
+        {
+            return QVariant((int)unity::shell::notifications::Type::TypeEnum::Invalid);
+        }
+    }
+    else if (role == Urgency)
+    {
+        return QVariant((int)unity::shell::notifications::Urgency::UrgencyEnum::Invalid);
+    }
+    else if (role == Body)
+    {
+        return QVariant("");
+    }
+    else if (role == Value)
+    {
+        return QVariant(0);
+    }
+    else if (role == Icon)
+    {
+        return QVariant::fromValue(QUrl(""));
+    }
+    else if (role == SecondaryIcon)
+    {
+        return QVariant::fromValue(QUrl(""));
+    }
+    else if (role == Hints)
+    {
+        return QVariant(unity::shell::notifications::Hint::Invalid);
+    }
+    else if (role == Actions)
+    {
+        return QVariant::fromValue(notification->m_actions);
+    }
+
+    return QVariant();
+}
+
+QHash<int, QByteArray>
+MockModel::roleNames() const
+{
+    return m_roles;
+}
+
+void
+MockModel::setConfirmationPlaceholder(bool confirmationPlaceholder)
+{
+    if (m_confirmationPlaceholder != confirmationPlaceholder)
+    {
+        m_confirmationPlaceholder = confirmationPlaceholder;
+
+        if (m_confirmationPlaceholder)
+        {
+            MockNotification* notification = new MockNotification(this);
+
+            notification->m_data.insert("type", (int)unity::shell::notifications::Type::TypeEnum::Placeholder);
+            connect(notification, SIGNAL(dismissed()), SLOT(onDismissed()));
+
+            beginInsertRows(QModelIndex(), 0, 0);
+            m_list.insert(0, notification);
+            endInsertRows();
+        }
+        else
+        {
+            if (m_list.count() > 0
+                    && m_list.at(0)->m_data.contains("type")
+                    && m_list.at(0)->m_data["type"] == (int)unity::shell::notifications::Type::TypeEnum::Placeholder)
+            {
+                MockNotification* notification = m_list.at(0);
+                beginRemoveRows(QModelIndex(), 0, 0);
+                m_list.removeAt(0);
+                endRemoveRows();
+                notification->deleteLater();
+            }
+        }
+
+        Q_EMIT confirmationPlaceholderChanged(m_confirmationPlaceholder);
+    }
+}
+
+void
+MockModel::add(MockNotification* notification)
+{
+    connect(notification, SIGNAL(dismissed()), SLOT(onDismissed()));
+    int row = -1;
+    if (m_confirmationPlaceholder
+            && notification->m_data.contains("type")
+            && notification->m_data["type"] == (int)unity::shell::notifications::Type::TypeEnum::Confirmation)
+    {
+        MockNotification* placeholder = m_list.at(0);
+        placeholder->m_data["type"] = (int)unity::shell::notifications::Type::TypeEnum::Confirmation;
+        Q_EMIT dataChanged(index(0), index(0));
+    }
+    else if (m_confirmationPlaceholder)
+    {
+        row = 1;
+    }
+    else
+    {
+        row = 0;
+    }
+
+    if (row >= 0)
+    {
+        beginInsertRows(QModelIndex(), row, row);
+        m_list.insert(row, notification);
+        endInsertRows();
+    }
+}
+
+void
+MockModel::onDismissed()
+{
+    MockNotification* notification = qobject_cast<MockNotification*>(sender());
+    int row = m_list.indexOf(notification);
+    if (row >= 0)
+    {
+        if (m_confirmationPlaceholder
+                && notification->m_data.contains("type")
+                && notification->m_data["type"] == (int)unity::shell::notifications::Type::TypeEnum::Confirmation)
+        {
+            notification->m_data["type"] = (int)unity::shell::notifications::Type::TypeEnum::Placeholder;
+            Q_EMIT dataChanged(index(0), index(0));
+        }
+        else
+        {
+            beginRemoveRows(QModelIndex(), row, row);
+            m_list.removeAt(row);
+            endRemoveRows();
+        }
+    }
+}

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockModel.h'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockModel.h	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockModel.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef MOCKMODEL_H
+#define MOCKMODEL_H
+
+#include <unity/config.h>
+
+#include <unity/shell/notifications/ModelInterface.h>
+
+#include <QtCore/QList>
+#include <QtCore/QVariantMap>
+
+using namespace unity::shell::notifications;
+
+class MockNotification;
+
+class UNITY_API MockModel : public ModelInterface
+{
+    Q_OBJECT
+
+    Q_ENUMS(RoleEnum)
+
+public:
+    MockModel(QObject* parent = 0);
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    QHash<int, QByteArray> roleNames() const;
+
+    bool confirmationPlaceholder() const
+    {
+        return m_confirmationPlaceholder;
+    }
+
+    void setConfirmationPlaceholder(bool confirmationPlaceholder);
+
+    void add(MockNotification* notification);
+
+    enum RoleEnum
+    {
+        Summary = Qt::DisplayRole,
+        Notification = Qt::UserRole,
+        Id,
+        Type,
+        Urgency,
+        Body,
+        Value,
+        Icon,
+        SecondaryIcon,
+        Hints,
+        Actions
+    };
+
+private:
+    bool m_confirmationPlaceholder;
+    QHash<int, QByteArray> m_roles;
+    QList<MockNotification*> m_list;
+
+private Q_SLOTS:
+    void onDismissed();
+};
+
+#endif // MOCKMODEL_H

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotification.cpp'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotification.cpp	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotification.cpp	2013-05-16 10:27:27 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#include <Mocks/MockNotification.h>
+#include <Mocks/MockActionModel.h>
+
+MockNotification::MockNotification(QObject* parent)
+    : NotificationInterface(parent)
+    , m_actions(new MockActionModel(this))
+{
+    connect(this, SIGNAL(dismissed()), SIGNAL(completed()));
+}

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotification.h'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotification.h	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotification.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef MOCKNOTIFICATION_H
+#define MOCKNOTIFICATION_H
+
+#include <unity/config.h>
+
+#include <unity/shell/notifications/NotificationInterface.h>
+
+#include <QtCore/QVariantMap>
+
+using namespace unity::shell::notifications;
+
+class MockSource;
+class MockModel;
+class MockActionModel;
+
+class UNITY_API MockNotification : public NotificationInterface
+{
+    friend class MockSource;
+    friend class MockModel;
+    friend class MockActionModel;
+
+    Q_OBJECT
+public:
+    explicit MockNotification(QObject *parent = 0);
+
+Q_SIGNALS:
+    void completed();
+
+private:
+    QVariantMap m_data;
+    MockActionModel* m_actions;
+};
+
+Q_DECLARE_METATYPE(MockNotification*)
+
+#endif // MOCKNOTIFICATION_H

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotificationsPlugin.cpp'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotificationsPlugin.cpp	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotificationsPlugin.cpp	2013-05-16 10:27:27 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#include <Mocks/MockNotificationsPlugin.h>
+#include <Mocks/MockSource.h>
+
+#include <unity/shell/notifications/SourceInterface.h>
+
+#include <qqml.h>
+
+using namespace unity::shell::notifications;
+
+void MockNotificationsPlugin::registerTypes(const char *uri)
+{
+    // @uri Unity.Notifications.Mocks
+    qmlRegisterUncreatableType<SourceInterface>(uri, 0, 1, "SourceInterface", "SourceInterface is an abstract base class");
+
+    qmlRegisterType<MockSource>(uri, 0, 1, "MockSource");
+}

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotificationsPlugin.h'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotificationsPlugin.h	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockNotificationsPlugin.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef MOCKNOTIFICATIONSPLUGIN_H
+#define MOCKNOTIFICATIONSPLUGIN_H
+
+#include <QQmlExtensionPlugin>
+
+class MockNotificationsPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+
+public:
+    void registerTypes(const char *uri);
+};
+
+#endif // MOCKNOTIFICATIONSPLUGIN_H

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockSource.cpp'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockSource.cpp	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockSource.cpp	2013-05-16 10:27:27 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#include <Mocks/MockSource.h>
+#include <Mocks/MockModel.h>
+#include <Mocks/MockNotification.h>
+
+#include <unity/shell/notifications/NotificationInterface.h>
+
+using namespace unity::shell::notifications;
+
+MockSource::MockSource(QObject *parent)
+    : SourceInterface(parent)
+    , m_model(0)
+{
+}
+
+ModelInterface*
+MockSource::model() const
+{
+    return m_model;
+}
+
+void
+MockSource::setModel(ModelInterface* model)
+{
+    MockModel* mockModel = qobject_cast<MockModel*>(model);
+    if (m_model != mockModel)
+    {
+        m_model = mockModel;
+        Q_EMIT modelChanged(m_model);
+    }
+}
+
+void
+MockSource::send(QVariantMap data)
+{
+    MockNotification* notification = new MockNotification(this);
+    notification->m_data = data;
+
+    connect(notification, SIGNAL(completed()), SLOT(onCompleted()));
+
+    if(m_model)
+    {
+        m_model->add(notification);
+    }
+}
+
+void
+MockSource::onCompleted()
+{
+    sender()->deleteLater();
+}

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockSource.h'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockSource.h	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/MockSource.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef MOCKSOURCE_H
+#define MOCKSOURCE_H
+
+#include <unity/config.h>
+
+#include <unity/shell/notifications/SourceInterface.h>
+
+#include <QtCore/QVariantMap>
+
+namespace unity
+{
+namespace shell
+{
+namespace notifications
+{
+
+class ModelInterface;
+
+} // namespace notifications
+} // namespace shell
+} // namespace unity
+
+class MockModel;
+
+using namespace unity::shell::notifications;
+
+class UNITY_API MockSource : public SourceInterface
+{
+    Q_OBJECT
+public:
+    explicit MockSource(QObject *parent = 0);
+
+    ModelInterface* model() const;
+
+    void setModel(ModelInterface* model);
+
+    Q_INVOKABLE void send(QVariantMap data);
+
+private Q_SLOTS:
+    void onCompleted();
+
+private:
+    MockModel* m_model;
+};
+
+#endif // MOCKSOURCE_H

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/Mocks/qmldir'
--- test/qmltest/mocks/plugins/Unity/Notifications/Mocks/qmldir	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/Mocks/qmldir	2013-05-16 10:27:27 +0000
@@ -0,0 +1,2 @@
+module Unity.Notifications.Mocks
+plugin MockNotificationsPlugin

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/TestNotificationsPlugin.cpp'
--- test/qmltest/mocks/plugins/Unity/Notifications/TestNotificationsPlugin.cpp	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/TestNotificationsPlugin.cpp	2013-05-16 10:27:27 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#include <TestNotificationsPlugin.h>
+#include <Mocks/MockModel.h>
+#include <Mocks/MockSource.h>
+#include <Mocks/MockNotification.h>
+
+#include <unity/shell/notifications/Enums.h>
+#include <unity/shell/notifications/ModelInterface.h>
+#include <unity/shell/notifications/SourceInterface.h>
+#include <unity/shell/notifications/NotificationInterface.h>
+
+#include <qqml.h>
+
+using namespace unity::shell::notifications;
+
+static QObject* modelProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)
+{
+    return new MockModel();
+}
+
+static QObject* sourceProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)
+{
+    return new MockSource();
+}
+
+void TestNotificationsPlugin::registerTypes(const char *uri)
+{
+    // @uri Unity.Notifications
+    qmlRegisterUncreatableType<Urgency>(uri, 0, 1, "Urgency", "Urgency is just a enum wrapper");
+    qmlRegisterUncreatableType<Type>(uri, 0, 1, "Type", "Type is just a enum wrapper");
+    qmlRegisterUncreatableType<Hint>(uri, 0, 1, "Hint", "Hint is just a enum wrapper");
+    qmlRegisterUncreatableType<NotificationInterface>(uri, 0, 1, "NotificationInterface", "NotificationInterface is an abstract base class");
+    qmlRegisterUncreatableType<ModelInterface>(uri, 0, 1, "ModelInterface", "ModelInterface is an abstract base class");
+    qmlRegisterUncreatableType<SourceInterface>(uri, 0, 1, "SourceInterface", "SourceInterface is an abstract base class");
+
+    qmlRegisterUncreatableType<MockNotification>(uri, 0, 1, "Notification", "Notification objects can only be created by the plugin");
+    qmlRegisterSingletonType<MockSource>(uri, 0, 1, "Source", sourceProvider);
+    qmlRegisterSingletonType<MockModel>(uri, 0, 1, "Model", modelProvider);
+}

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/TestNotificationsPlugin.h'
--- test/qmltest/mocks/plugins/Unity/Notifications/TestNotificationsPlugin.h	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/TestNotificationsPlugin.h	2013-05-16 10:27:27 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Michał Sawicz <[e-mail]>
+ */
+
+
+#ifndef TESTNOTIFICATIONS_PLUGIN_H
+#define TESTNOTIFICATIONS_PLUGIN_H
+
+#include <QQmlExtensionPlugin>
+
+class TestNotificationsPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+
+public:
+    void registerTypes(const char *uri);
+};
+
+#endif // TESTNOTIFICATIONS_PLUGIN_H

=== added file 'test/qmltest/mocks/plugins/Unity/Notifications/qmldir'
--- test/qmltest/mocks/plugins/Unity/Notifications/qmldir	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Notifications/qmldir	2013-05-16 10:27:27 +0000
@@ -0,0 +1,2 @@
+module Unity.Notifications
+plugin TestNotificationsPlugin

=== added directory 'test/qmltest/unity'
=== added file 'test/qmltest/unity/CMakeLists.txt'
--- test/qmltest/unity/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ test/qmltest/unity/CMakeLists.txt	2013-05-16 10:27:27 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(shell)

=== added directory 'test/qmltest/unity/shell'
=== added file 'test/qmltest/unity/shell/CMakeLists.txt'
--- test/qmltest/unity/shell/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ test/qmltest/unity/shell/CMakeLists.txt	2013-05-16 10:27:27 +0000
@@ -0,0 +1,9 @@
+include(QmlTest)
+
+set(qmltest_DEFAULT_IMPORT_PATHS
+  ${CMAKE_BINARY_DIR}/test/qmltest/modules
+  ${CMAKE_BINARY_DIR}/test/qmltest/mocks/plugins
+)
+set(qmltest_DEFAULT_PROPERTIES ENVIRONMENT "QT_QPA_PLATFORM=minimal")
+
+add_qml_test(notifications Notifications)

=== added directory 'test/qmltest/unity/shell/notifications'
=== added file 'test/qmltest/unity/shell/notifications/tst_Notifications.qml'
--- test/qmltest/unity/shell/notifications/tst_Notifications.qml	1970-01-01 00:00:00 +0000
+++ test/qmltest/unity/shell/notifications/tst_Notifications.qml	2013-05-16 10:27:27 +0000
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import QtTest 1.0
+import TestUtil 0.1
+import Unity.Notifications 0.1
+import Unity.Notifications.Mocks 0.1 as Mocks
+
+Item {
+
+    Mocks.MockSource {
+        id: mockSource
+    }
+
+    Verifier {
+        id: typeTestCase
+
+        property var model: Model
+        property var source: Source
+
+        function cleanup() {
+            clear();
+            Source.model = null;
+        }
+
+        function test_types_data() {
+            return [
+                { name: "Urgency", tag: "Urgency.Invalid", enum: "Invalid" },
+                { name: "Urgency", tag: "Urgency.Low", enum: "Low" },
+                { name: "Urgency", tag: "Urgency.Normal", enum: "Normal" },
+                { name: "Urgency", tag: "Urgency.Critical", enum: "Critical" },
+                { name: "Type", tag: "Type.Invalid", enum: "Invalid" },
+                { name: "Type", tag: "Type.Confirmation", enum: "Confirmation" },
+                { name: "Type", tag: "Type.Ephemeral", enum: "Ephemeral" },
+                { name: "Type", tag: "Type.Interactive", enum: "Ephemeral" },
+                { name: "Type", tag: "Type.SnapDecision", enum: "SnapDecision" },
+                { name: "Type", tag: "Type.Placeholder", enum: "Placeholder" },
+                { name: "Hint", tag: "Hint.Invalid", enum: "Invalid" },
+                { name: "Hint", tag: "Hint.ButtonTint", enum: "ButtonTint" },
+                { name: "Hint", tag: "Hint.IconOnly", enum: "IconOnly" },
+                { name: "Notification", tag: "Notification" },
+            ];
+        }
+
+        function test_types(data) {
+            try {
+                object = eval(data.name);
+            } catch(err) {
+                object = undefined;
+            }
+            name = data.name;
+
+            verifyData(data);
+        }
+
+        function test_model_data() {
+            return [
+                { tag: "Model[object]", type: "object" },
+                { tag: "Model[ModelInterface]", type: "unity::shell::notifications::ModelInterface" },
+                { tag: "Model.confirmationPlaceholder", writable: "confirmationPlaceholder",
+                  type: "boolean", value: !Model.confirmationPlaceholder }
+            ];
+        }
+
+        function test_model(data) {
+            object = model;
+            name = "Model"
+
+            verifyData(data);
+        }
+
+        function test_source_data() {
+            return [
+                { tag: "Source[object]", type: "object" },
+                { tag: "Source[SourceInterface]", type: "unity::shell::notifications::SourceInterface" },
+                { tag: "Source.model", writable: "model", type: "object", value: model },
+            ];
+        }
+
+        function test_source(data) {
+            object = source;
+            name = "Source"
+
+            verifyData(data);
+        }
+    }
+
+    Verifier {
+       when: typeTestCase.completed
+       optional: true
+
+       Repeater {
+           id: repeater
+           delegate: Item {
+               id: item
+               property var roles: model
+               property Repeater actionRepeater: actions
+
+               Repeater {
+                   id: actions
+                   model: parent.roles.actions
+                   delegate: Item {
+                       property var roles: model
+                   }
+               }
+           }
+       }
+
+       SignalSpy {
+           id: dataSpy
+           signalName: "dataChanged"
+       }
+
+       function initTestCase() {
+           repeater.model = Model;
+           dataSpy.target = Model;
+           mockSource.model = Model;
+       }
+
+       function init() {
+           tryCompare(repeater, "count", 0);
+       }
+
+       function cleanup() {
+           Model.confirmationPlaceholder = false;
+           // dismiss all Notifications
+           for (var i = 0; i < repeater.count; i++) {
+               repeater.itemAt(i).roles.notification.dismissed()
+           }
+           dataSpy.clear()
+           tryCompare(repeater, "count", 0);
+       }
+
+       /* make sure all the required roles are exposed on Model */
+       function test_model_roles_data() {
+           return [
+               { tag: "Model.roles[notification]", role: "notification", type: "object" },
+               { tag: "Model.roles[type]", role: "type", type: "number" },
+               { tag: "Model.roles[urgency]", role: "urgency", type: "number" },
+               { tag: "Model.roles[id]", role: "id", type: "number" },
+               { tag: "Model.roles[summary]", role: "summary", type: "string" },
+               { tag: "Model.roles[body]", role: "body", type: "string" },
+               { tag: "Model.roles[value]", role: "value", type: "number" },
+               { tag: "Model.roles[icon]", role: "icon", type: "object" },
+               { tag: "Model.roles[secondaryIcon]", role: "secondaryIcon", type: "object" },
+               { tag: "Model.roles[actions]", role: "actions", type: "object" },
+               { tag: "Model.roles[hints]", role: "hints", type: "number" },
+           ];
+       }
+
+       function test_model_roles(data) {
+           mockSource.send({});
+           tryCompare(repeater, "count", 1);
+
+           try {
+               object = repeater.itemAt(0).roles;
+           } catch(err) {
+               object = undefined;
+           }
+           name = "Model";
+
+           verifyData(data);
+       }
+
+       /* make sure all the members of Notification objects are available */
+       function test_notification_members_data() {
+            return [
+                { tag: "Notification.dismissed", signal: "dismissed" },
+                { tag: "Notification.hovered", signal: "hovered" },
+                { tag: "Notification.displayed", signal: "displayed" },
+                { tag: "Notification.actionInvoked", signal: "actionInvoked" }
+            ];
+       }
+
+       function test_notification_members(data) {
+           mockSource.send({});
+           tryCompare(repeater, "count", 1);
+
+           try {
+               object = repeater.itemAt(0).roles.notification;
+           } catch(err) {
+               object = undefined;
+           }
+           name = "Notification";
+
+           verifyData(data);
+       }
+
+       /* make sure all the required roles for actions are exposed */
+       function test_action_members_data() {
+           return [
+               { tag: "actions.roles[label]", role: "label", type: "string" },
+               { tag: "actions.roles[id]", role: "id", type: "string" }
+           ];
+       }
+
+       function test_action_members(data) {
+           mockSource.send({
+               "actions": [
+                   {"label": "test", "id": "test"}
+               ]
+           });
+           tryCompare(repeater, "count", 1);
+           tryCompare(repeater.itemAt(0).actionRepeater, "count", 1);
+
+           try {
+               object = repeater.itemAt(0).actionRepeater.itemAt(0).roles;
+           } catch(err) {
+               object = undefined;
+           }
+           name = "actions";
+
+           verifyData(data);
+       }
+
+       /* make sure the model is empty by default */
+       function test_empty() {
+           tryCompare(repeater, "count", 0);
+       }
+
+       /* make sure there is a placeholder item used as the first one when
+          confirmationPlaceholder is true and that any additional notification is added
+          after it */
+       function test_placeholder() {
+           Model.confirmationPlaceholder = true;
+           tryCompare(repeater, "count", 1);
+
+           compare(repeater.itemAt(0).roles.type, Type.Placeholder, "the notification should be of Placeholder type");
+           mockSource.send({
+               type: Type.Ephemeral
+           })
+           tryCompare(repeater, "count", 2);
+
+           compare(repeater.itemAt(0).roles.type, Type.Placeholder, "the first notification should be of Placeholder type");
+           compare(repeater.itemAt(1).roles.type, Type.Ephemeral, "the second notification should be of Ephemeral type");
+       }
+
+       /* make sure the placeholder item is updated with roles incoming in a Confirmation
+          notification */
+       function test_confirmation() {
+           Model.confirmationPlaceholder = true;
+           tryCompare(repeater, "count", 1);
+           mockSource.send({
+               "type": Type.Confirmation
+           });
+           tryCompare(repeater, "count", 1);
+           dataSpy.wait();
+           compare(repeater.count, 1, "there should be only one notification");
+           compare(repeater.itemAt(0).roles.type, Type.Confirmation, "the first notification should be of Confirmation type");
+       }
+    }
+}