Merge lp:~veebers/autopilot-qt/enable-datamodel-elements-add-new-nodes into lp:autopilot-qt

[Christopher Lee]

Adding new data model nodes.

Implementing the new data-index style nodes so we can introspect them.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:87
http://jenkins.qa.ubuntu.com/job/autopilot-qt-ci/16/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-amd64-ci/1
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/1
        deb: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/1/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-i386-ci/1

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-qt-ci/16/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:93
http://jenkins.qa.ubuntu.com/job/autopilot-qt-ci/18/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-amd64-ci/3
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/3
        deb: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/3/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-i386-ci/3

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-qt-ci/18/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:95
http://jenkins.qa.ubuntu.com/job/autopilot-qt-ci/20/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-amd64-ci/5
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/5
        deb: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/5/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-i386-ci/5

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-qt-ci/20/rebuild

review: Approve (continuous-integration)

[Thomi Richards (thomir-deactivatedaccount)]

Hi,

There's still a few things that need to be cleaned up - see diff comments below.

review: Needs Fixing

[Thomi Richards (thomir-deactivatedaccount)]

Just one comment, but I haven't given it an in-depth review.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:109
http://jenkins.qa.ubuntu.com/job/autopilot-qt-ci/22/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-amd64-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/7
        deb: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/7/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-i386-ci/7

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-qt-ci/22/rebuild

review: Approve (continuous-integration)

[Leo Arias (elopio)]

27 +inline int32_t calclulate_ap_id(quint64 big_id)

I think this is a typo ^. It should be calculate. But you are using it in so many places, it might be one of those correct English variations I have never heard before.

It might be good to put a comment there, because it's not really clear why you are shortening a big id instead of using always a data type that fits small and big ids.

255 + // Do any special children handling if needed.
[...]
298 + }
299 +

It would be clearer to extract all the ifs into a method. Also, the only thing that changes on each condition is the cast type. That can be parameterized and put into a method, right?

340 + // Make an attempt to store the 'text' of a node to be user friendly-ish.
[...]
369 + properties["globalRect"] = PackProperty(global_rect);

It would also be clearer to extract some of the calls into methods.

I can't see anything obviously wrong, but as I told you there are so many new things in this branch that some big things might have escaped me.

[Thomi Richards (thomir-deactivatedaccount)]

Looks good, except for comments made in the diff and on IRC.

[09:59:27] <veebers> thomi: sure, https://code.launchpad.net/~veebers/autopilot-qt/enable-datamodel-elements-add-new-nodes/+merge/224061
[09:59:49] <thomi> ok
[10:00:17] <thomi> veebers: hmmm
[10:00:29] <thomi> do you mind making a seemingly trivial, but important change?
[10:00:34] <thomi> actually, scratch that..
[10:00:52] <thomi> instead, imagine I said "please make this seemingly trivial, but important change" :P
[10:01:02] <thomi> veebers: in C++, please prefer:
[10:01:26] <thomi> 'Type const& name' over 'const Type& name'
[10:01:48] <thomi> same with pointers, it should be: 'Type const* name'
[10:02:06] <thomi> you read type declarations right-to-left, so:
[10:02:12] <veebers> thomi: ah sure, I'll make that change in a moment
[10:02:24] <thomi> 'QString const& name' is 'name is a reference to a const QString'
[10:02:46] <thomi> this isn't so important for references (but please change it still), but for pointers it's more critical, for example:
[10:03:01] <thomi> 'Foo const* const p'
[10:03:03] <thomi> or
[10:03:14] <thomi> 'p is a const pointer to a const Foo'
[10:03:38] <veebers> make sense
[10:03:40] <thomi> since you can also have 'Foo* const p' and 'Foo const* p'
[10:03:47] <thomi> and they're all different things :)
[10:04:29] <thomi> veebers: also, in GetDataElementChildren, can parent be const?
[10:05:00] <thomi> it will require all the parent parameters in all the QtNode-type classes to also be const, but they should be anyway
[10:05:47] <veebers> thomi: I'm pretty sure it can be
[10:06:15] <veebers> cool, I'll get that sorted too
[10:07:07] <thomi> veebers: also in those functions, I wonder if you can make the qDebug messages a bit more useful?
[10:07:25] <thomi> "Unable to retrieve model for QTreeView" doesn't sound like it's going to be useful to us while trying to debug things
[10:07:46] <veebers> thomi: understood, i'll make the message better
[10:07:50] <thomi> why can't we get the items, and which tree view is it?
[10:15:54] <thomi> veebers: You don't need to mark this as explicit: "QModelIndexNode(QModelIndex index, QAbstractItemView* parent_view)"
[10:16:09] <thomi> C++ only does implicit type conversion on single parameter ctors
[10:16:21] <veebers> thomi: oh, noted. Good catch
[10:17:04] <thomi> veebers: do you really need two ctors?
[10:17:14] <thomi> What's the use case for the one without the dbu parent node?
[10:17:34] <veebers> thomi: hmm, that might be a mistake, I'll check that wehn I make the other changes
[10:18:31] <thomi> veebers: also, what's the rationale for wanting to split the unit tests into multiple projects?
[10:19:55] <veebers> thomi: I wanted to have a separation of the tests for introspection and tests for the QtNode and this was my attempt at doing so. I initially tried to use 2 classes in the same file etc. but ended up soing it this way so I could get the tests written
[10:20:11] <veebers> thomi: If there is a better way I'm more than happy to make it happen
[10:20:21] <thomi> but why not have two test files in the same project?
[10:20:40] <thomi> I don't think you need a separate project, and therefore separate executables for ea...

review: Needs Fixing

[lp:~veebers/autopilot-qt/enable-datamodel-elements-add-new-nodes]

110. By Christopher Lee on 2014-07-20

Fix spelling mistake.

111. By Christopher Lee on 2014-07-20

Fixed cont Type& to Type const&

112. By Christopher Lee on 2014-07-20

const change for operators too

113. By Christopher Lee on 2014-07-21

Improve qDebug messages

114. By Christopher Lee on 2014-07-21

Remove un-needed constructors (Always need a parent for these types.)

115. By Christopher Lee on 2014-07-21

Make unittests a single project and executable.

116. By Christopher Lee on 2014-07-21

Added comment as per MP

117. By Christopher Lee on 2014-07-21

Actually add the other test files.

118. By Christopher Lee on 2014-07-21

Fix broken test.

119. By Christopher Lee on 2014-07-21

Move special children check into reusable function.

120. By Christopher Lee on 2014-07-21

Fix failing test, need to break once collected special children.

121. By Christopher Lee on 2014-07-21

Clean up QModelIndexNode::GetProperties

[Thomi Richards (thomir-deactivatedaccount)]

LGTM

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:121
http://jenkins.qa.ubuntu.com/job/autopilot-qt-ci/23/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-amd64-ci/8
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/8
        deb: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-armhf-ci/8/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-utopic-i386-ci/8

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-qt-ci/23/rebuild

review: Approve (continuous-integration)

[lp:~veebers/autopilot-qt/enable-datamodel-elements-add-new-nodes]

122. By Christopher Lee on 2014-07-24

Remove inline from calculate_ap_id

=== modified file 'driver/qtnode.cpp'
--- driver/qtnode.cpp	2014-07-24 23:49:59 +0000
+++ driver/qtnode.cpp	2014-07-24 23:49:59 +0000
@@ -17,8 +17,37 @@
 #endif
 #include <QDBusArgument>
 
+#include <QAbstractItemView>
+#include <QAbstractProxyModel>
+#include <QTableWidget>
+#include <QTreeView>
+#include <QTreeWidget>
+#include <QListView>
+
+const QByteArray AP_ID_NAME("_autopilot_id");
+
+void CollectSpecialChildren(QObject* object, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+
+void GetDataElementChildren(QTableWidget* table, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void GetDataElementChildren(QTreeView* tree_view, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void GetDataElementChildren(QTreeWidget* tree_widget, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void GetDataElementChildren(QListView* list_view, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+
+void CollectAllIndices(QModelIndex index, QAbstractItemModel *model, QModelIndexList &collection);
+QVariant SafePackProperty(QVariant const& prop);
+
+bool MatchProperty(QVariantMap const& packed_properties, std::string const& name, QVariant value);
+
+// Produce an id suitable for xpathselects' GetId
+int32_t calculate_ap_id(quint64 big_id)
+{
+    int32_t high = static_cast<int32_t>(big_id >> 32);
+    int32_t low = static_cast<int32_t>(big_id);
+    return high ^ low;
+}
+
 // Marshall the NodeIntrospectionData data into a D-Bus argument
-QDBusArgument &operator<<(QDBusArgument &argument, const NodeIntrospectionData &node_data)
+QDBusArgument &operator<<(QDBusArgument &argument, NodeIntrospectionData const& node_data)
 {
     argument.beginStructure();
     argument << node_data.object_path << node_data.state;
@@ -27,7 +56,7 @@
 }
 
 // Retrieve the NodeIntrospectionData data from the D-Bus argument
-const QDBusArgument &operator>>(const QDBusArgument &argument, NodeIntrospectionData &node_data)
+const QDBusArgument &operator>>(QDBusArgument const& argument, NodeIntrospectionData& node_data)
 {
     argument.beginStructure();
     argument >> node_data.object_path >> node_data.state;
@@ -35,7 +64,142 @@
     return argument;
 }
 
-const QByteArray AP_ID_NAME("_autopilot_id");
+void GetDataElementChildren(QTableWidget *table, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    QList<QTableWidgetItem *> tablewidgetitems = table->findItems("*", Qt::MatchWildcard|Qt::MatchRecursive);
+    foreach (QTableWidgetItem *item, tablewidgetitems){
+        children.push_back(
+            std::make_shared<QTableWidgetItemNode>(item, parent)
+            );
+    }
+}
+
+void CollectAllIndices(QModelIndex index, QAbstractItemModel *model, QModelIndexList &collection)
+{
+    for(int c=0; c < model->columnCount(index); ++c) {
+        for(int r=0; r < model->rowCount(index); ++r) {
+            QModelIndex new_index = model->index(r, c, index);
+            collection.push_back(new_index);
+            if(new_index.isValid() && qHash(new_index) != qHash(index)) {
+                CollectAllIndices(new_index, model, collection);
+            }
+        }
+    }
+}
+
+// Pack property, but return a default blank if the packed property is invalid.
+QVariant SafePackProperty(QVariant const& prop)
+{
+    static QVariant blank_default = PackProperty("");
+
+    QVariant property_attempt = PackProperty(prop);
+    if(property_attempt.isValid())
+        return property_attempt;
+    else
+        return blank_default;
+}
+
+bool MatchProperty(QVariantMap const& packed_properties, std::string const& name, QVariant value)
+{
+    QString qname = QString::fromStdString(name);
+    if (! packed_properties.contains(qname))
+        return false;
+
+    // Because the properties are packed, we need the value, not the type.
+    QVariant object_value = qvariant_cast<QVariantList>(packed_properties[qname]).at(1);
+    if (value.canConvert(object_value.type()))
+    {
+        value.convert(object_value.type());
+        return value == object_value;
+    }
+    return false;
+}
+
+
+void GetDataElementChildren(QTreeView* tree_view, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    QAbstractItemModel* abstract_model = tree_view->model();
+    if(! abstract_model)
+    {
+        qDebug() << "Unable to get element children from QTreeView "
+                 << "with objectName '" << tree_view->objectName() << "'. "
+                 << "No model found.";
+        return;
+    }
+
+    QModelIndexList all_indices;
+    for(int c=0; c < abstract_model->columnCount(); ++c) {
+        for(int r=0; r < abstract_model->rowCount(); ++r) {
+            QModelIndex index = abstract_model->index(r, c);
+            all_indices.push_back(index);
+            CollectAllIndices(index, abstract_model, all_indices);
+        }
+    }
+
+    foreach(QModelIndex index, all_indices)
+    {
+        if(index.isValid())
+        {
+            children.push_back(
+                std::make_shared<QModelIndexNode>(
+                    index,
+                    tree_view,
+                    parent)
+                );
+        }
+    }
+}
+
+void GetDataElementChildren(QTreeWidget* tree_widget, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    for(int i=0; i < tree_widget->topLevelItemCount(); ++i) {
+        children.push_back(
+            std::make_shared<QTreeWidgetItemNode>(
+                tree_widget->topLevelItem(i),
+                parent)
+            );
+    }
+}
+
+void GetDataElementChildren(QListView* list_view, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    QAbstractItemModel* abstract_model = list_view->model();
+
+    if(! abstract_model) {
+        qDebug() << "Unable to get element children from QListView "
+                 << "with objectName '" << list_view->objectName() << "'. "
+                 << "No model found.";
+        return;
+    }
+
+    QModelIndexList all_indices;
+    QModelIndex root_index = list_view->rootIndex();
+    if(root_index.isValid()) {
+        // The root item is the parent item to the view's toplevel items
+        CollectAllIndices(root_index, abstract_model, all_indices);
+    }
+    else {
+        for(int c=0; c < abstract_model->columnCount(); ++c) {
+            for(int r=0; r < abstract_model->rowCount(); ++r) {
+                QModelIndex index = abstract_model->index(r, c);
+                all_indices.push_back(index);
+                CollectAllIndices(index, abstract_model, all_indices);
+            }
+        }
+    }
+
+    foreach(QModelIndex index, all_indices) {
+        if(index.isValid())
+        {
+            children.push_back(
+                std::make_shared<QModelIndexNode>(
+                    index,
+                    list_view,
+                    parent)
+                );
+        }
+    }
+}
 
 QObjectNode::QObjectNode(QObject *obj, DBusNode::Ptr parent)
 : object_(obj)
@@ -70,7 +234,6 @@
     QString name = object_->metaObject()->className();
 
     // QML type names get mangled by Qt - they get _QML_N or _QMLTYPE_N appended.
-    //
     if (name.contains('_'))
         name = name.split('_').front();
     return name.toStdString();
@@ -97,71 +260,62 @@
     return qvariant_cast<int32_t>(object_->property(AP_ID_NAME));
 }
 
-bool QObjectNode::MatchStringProperty(const std::string& name, const std::string& value) const
+bool QObjectNode::MatchStringProperty(std::string const& name, std::string const& value) const
 {
-    QVariantMap properties = GetNodeProperties(object_);
-
-    QString qname = QString::fromStdString(name);
-    if (! properties.contains(qname))
-        return false;
-
-    QVariant object_value = qvariant_cast<QVariantList>(properties[qname]).at(1);
-    QVariant check_value(QString::fromStdString(value));
-    if (check_value.canConvert(object_value.type()))
-    {
-        check_value.convert(object_value.type());
-        return check_value == object_value;
-    }
-
-    return false;
+    return MatchProperty(GetNodeProperties(object_), name, QString::fromStdString(value));
 }
 
-bool QObjectNode::MatchIntegerProperty(const std::string& name, int32_t value) const
+bool QObjectNode::MatchIntegerProperty(std::string const& name, int32_t value) const
 {
     if (name == "id")
         return value == GetId();
 
-    QVariantMap properties = GetNodeProperties(object_);
-
-    QString qname = QString::fromStdString(name);
-    if (! properties.contains(qname))
-        return false;
-
-    QVariant object_value = qvariant_cast<QVariantList>(properties[qname]).at(1);
-    QVariant check_value(value);
-    if (check_value.canConvert(object_value.type()))
-    {
-        check_value.convert(object_value.type());
-        return check_value == object_value;
-    }
-
-    return false;
-}
-
-bool QObjectNode::MatchBooleanProperty(const std::string& name, bool value) const
-{
-    QVariantMap properties = GetNodeProperties(object_);
-
-    QString qname = QString::fromStdString(name);
-    if (! properties.contains(qname))
-        return false;
-
-    QVariant object_value = qvariant_cast<QVariantList>(properties[qname]).at(1);
-    QVariant check_value(value);
-
-    if (check_value.canConvert(object_value.type()))
-    {
-        check_value.convert(object_value.type());
-        return check_value == object_value;
-    }
-
-    return false;
+    return MatchProperty(GetNodeProperties(object_), name, value);
+}
+
+bool QObjectNode::MatchBooleanProperty(std::string const& name, bool value) const
+{
+    return MatchProperty(GetNodeProperties(object_), name, value);
+}
+
+template <class T>
+bool AttemptGetSpecialChildren(QObject* object, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    auto className = T::staticMetaObject.className();
+    if(object->inherits(className))
+    {
+        T* table = qobject_cast<T *>(object);
+        if(table) {
+            GetDataElementChildren(table, children, parent);
+        }
+        else {
+            qDebug() << "Casting object (with objectName: " << object->objectName() << ") "
+                     << "to " << className
+                     << "failed. Unable to retrieve children.";
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+
+void CollectSpecialChildren(QObject* object, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    // Need to make sure to make these checks in the correct order.
+    // i.e. Because QTreeWidget inherits from QTreeView do it first otherwise
+    // we would never reach the specific QTreeWidget code.
+    AttemptGetSpecialChildren<QTableWidget>(object, children, parent)
+        || AttemptGetSpecialChildren<QTreeWidget>(object, children, parent)
+        || AttemptGetSpecialChildren<QTreeView>(object, children, parent)
+        || AttemptGetSpecialChildren<QListView>(object, children, parent);
 }
 
 xpathselect::NodeVector QObjectNode::Children() const
 {
     xpathselect::NodeVector children;
 
+    CollectSpecialChildren(object_, children, shared_from_this());
+
 #ifdef QT5_SUPPORT
     // Qt5's hierarchy for QML has changed a bit:
     // - On top there's a QQuickView which holds all the QQuick items
@@ -219,3 +373,274 @@
 {
     return parent_;
 }
+
+// QModelIndexNode
+QModelIndexNode::QModelIndexNode(QModelIndex index, QAbstractItemView* parent_view, DBusNode::Ptr parent)
+    : index_(index)
+    , parent_view_(parent_view)
+    , parent_(parent)
+{
+    std::string parent_path = parent ? parent->GetPath() : "";
+    full_path_ = parent_path + "/" + GetName();
+}
+
+NodeIntrospectionData QModelIndexNode::GetIntrospectionData() const
+{
+    NodeIntrospectionData data;
+    data.object_path = QString::fromStdString(GetPath());
+    data.state = GetProperties();
+    data.state["id"] = PackProperty(GetId());
+    return data;
+}
+
+QVariantMap QModelIndexNode::GetProperties() const
+{
+    QVariantMap properties;
+    const QAbstractItemModel* model = index_.model();
+    if(model)
+    {
+        // Make an attempt to store the 'text' of a node to be user friendly-ish.
+        properties["text"] = SafePackProperty(model->data(index_));
+
+        // Include any Role data (mung the role name with added "Role")
+        const QHash<int, QByteArray> role_names = model->roleNames();
+        QMap<int, QVariant> item_data = model->itemData(index_);
+        foreach(int name, role_names.keys())
+        {
+            if(item_data.contains(name)) {
+                properties[role_names[name]+"Role"] = SafePackProperty(item_data[name]);
+            }
+            else {
+                properties[role_names[name]+"Role"] = PackProperty("");
+            }
+        }
+    }
+
+    QRect rect = parent_view_->visualRect(index_);
+    QRect global_rect(
+        parent_view_->viewport()->mapToGlobal(rect.topLeft()),
+        rect.size());
+    QRect viewport_contents = parent_view_->viewport()->contentsRect();
+    properties["onScreen"] = PackProperty(viewport_contents.contains(rect));
+    properties["globalRect"] = PackProperty(global_rect);
+
+    return properties;
+}
+
+xpathselect::Node::Ptr QModelIndexNode::GetParent() const
+{
+    return parent_;
+}
+
+std::string QModelIndexNode::GetName() const
+{
+    return "QModelIndex";
+}
+
+std::string QModelIndexNode::GetPath() const
+{
+    return full_path_;
+}
+
+int32_t QModelIndexNode::GetId() const
+{
+    return calculate_ap_id(static_cast<quint64>(qHash(index_)));
+}
+
+bool QModelIndexNode::MatchStringProperty(std::string const& name, std::string const& value) const
+{
+    return MatchProperty(GetProperties(), name, QString::fromStdString(value));
+}
+
+bool QModelIndexNode::MatchIntegerProperty(std::string const& name, int32_t value) const
+{
+    if (name == "id")
+        return value == GetId();
+
+    return MatchProperty(GetProperties(), name, value);
+}
+
+bool QModelIndexNode::MatchBooleanProperty(std::string const& name, bool value) const
+{
+    return MatchProperty(GetProperties(), name, value);
+}
+
+xpathselect::NodeVector QModelIndexNode::Children() const
+{
+    // Doesn't have any children.
+    xpathselect::NodeVector children;
+    return children;
+}
+
+// QTableWidgetItemNode
+QTableWidgetItemNode::QTableWidgetItemNode(QTableWidgetItem *item, DBusNode::Ptr parent)
+    : item_(item)
+    , parent_(parent)
+{
+    std::string parent_path = parent ? parent->GetPath() : "";
+    full_path_ = parent_path + "/" + GetName();
+}
+
+NodeIntrospectionData QTableWidgetItemNode::GetIntrospectionData() const
+{
+    NodeIntrospectionData data;
+    data.object_path = QString::fromStdString(GetPath());
+    data.state = GetProperties();
+    data.state["id"] = PackProperty(GetId());
+    return data;
+}
+
+QVariantMap QTableWidgetItemNode::GetProperties() const
+{
+    QVariantMap properties;
+
+    QTableWidget* parent = item_->tableWidget();
+    QRect cellrect = parent->visualItemRect(item_);
+    QRect r = QRect(parent->mapToGlobal(cellrect.topLeft()), cellrect.size());
+    properties["globalRect"] = PackProperty(r);
+
+    properties["text"] = SafePackProperty(PackProperty(item_->text()));
+    properties["toolTip"] = SafePackProperty(PackProperty(item_->toolTip()));
+    properties["icon"] = SafePackProperty(PackProperty(item_->icon()));
+    properties["whatsThis"] = SafePackProperty(PackProperty(item_->whatsThis()));
+    properties["row"] = SafePackProperty(PackProperty(item_->row()));
+    properties["isSelected"] = SafePackProperty(PackProperty(item_->isSelected()));
+    properties["column"] = SafePackProperty(PackProperty(item_->column()));
+
+    return properties;
+}
+
+xpathselect::Node::Ptr QTableWidgetItemNode::GetParent() const
+{
+    return parent_;
+}
+
+std::string QTableWidgetItemNode::GetName() const
+{
+    return "QTableWidgetItem";
+}
+
+std::string QTableWidgetItemNode::GetPath() const
+{
+    return full_path_;
+}
+
+int32_t QTableWidgetItemNode::GetId() const
+{
+    return calculate_ap_id(static_cast<quint64>(reinterpret_cast<quintptr>(item_)));
+}
+
+bool QTableWidgetItemNode::MatchStringProperty(std::string const& name, std::string const& value) const
+{
+    return MatchProperty(GetProperties(), name, QString::fromStdString(value));
+}
+
+bool QTableWidgetItemNode::MatchIntegerProperty(std::string const& name, int32_t value) const
+{
+    if (name == "id")
+        return value == GetId();
+
+    return MatchProperty(GetProperties(), name, value);
+}
+
+bool QTableWidgetItemNode::MatchBooleanProperty(std::string const& name, bool value) const
+{
+    return MatchProperty(GetProperties(), name, value);
+}
+
+xpathselect::NodeVector QTableWidgetItemNode::Children() const
+{
+    // Doesn't have any children.
+    xpathselect::NodeVector children;
+    return children;
+}
+
+// QTreeWidgetItemNode
+QTreeWidgetItemNode::QTreeWidgetItemNode(QTreeWidgetItem *item, DBusNode::Ptr parent)
+    : item_(item)
+    , parent_(parent)
+{
+    std::string parent_path = parent ? parent->GetPath() : "";
+    full_path_ = parent_path + "/" + GetName();
+}
+
+NodeIntrospectionData QTreeWidgetItemNode::GetIntrospectionData() const
+{
+    NodeIntrospectionData data;
+    data.object_path = QString::fromStdString(GetPath());
+    data.state = GetProperties();
+    data.state["id"] = PackProperty(GetId());
+    return data;
+}
+
+QVariantMap QTreeWidgetItemNode::GetProperties() const
+{
+    QVariantMap properties;
+    QTreeWidget* parent = item_->treeWidget();
+    QRect cellrect = parent->visualItemRect(item_);
+    QRect r = QRect(parent->viewport()->mapToGlobal(cellrect.topLeft()), cellrect.size());
+    properties["globalRect"] = PackProperty(r);
+
+    properties["text"] = SafePackProperty(item_->text(0));
+    properties["columns"] = SafePackProperty(item_->columnCount());
+    properties["checkState"] = SafePackProperty(item_->checkState(0));
+
+    properties["isDisabled"] = SafePackProperty(item_->isDisabled());
+    properties["isExpanded"] = SafePackProperty(item_->isExpanded());
+    properties["isFirstColumnSpanned"] = SafePackProperty(item_->isFirstColumnSpanned());
+    properties["isHidden"] = SafePackProperty(item_->isHidden());
+    properties["isSelected"] = SafePackProperty(item_->isSelected());
+
+    return properties;
+}
+
+xpathselect::Node::Ptr QTreeWidgetItemNode::GetParent() const
+{
+    return parent_;
+}
+
+std::string QTreeWidgetItemNode::GetName() const
+{
+    return "QTreeWidgetItem";
+}
+
+std::string QTreeWidgetItemNode::GetPath() const
+{
+    return full_path_;
+}
+
+int32_t QTreeWidgetItemNode::GetId() const
+{
+    return calculate_ap_id(static_cast<quint64>(reinterpret_cast<quintptr>(item_)));
+}
+
+bool QTreeWidgetItemNode::MatchStringProperty(std::string const& name, std::string const& value) const
+{
+    return MatchProperty(GetProperties(), name, QString::fromStdString(value));
+}
+
+bool QTreeWidgetItemNode::MatchIntegerProperty(std::string const& name, int32_t value) const
+{
+    if (name == "id")
+        return value == GetId();
+
+    return MatchProperty(GetProperties(), name, value);
+}
+
+bool QTreeWidgetItemNode::MatchBooleanProperty(std::string const& name, bool value) const
+{
+    return MatchProperty(GetProperties(), name, value);
+}
+
+xpathselect::NodeVector QTreeWidgetItemNode::Children() const
+{
+    xpathselect::NodeVector children;
+
+    for(int i=0; i < item_->childCount(); ++i) {
+        children.push_back(
+            std::make_shared<QTreeWidgetItemNode>(item_->child(i),shared_from_this())
+            );
+    }
+
+    return children;
+}

=== modified file 'driver/qtnode.h'
--- driver/qtnode.h	2014-07-24 23:49:59 +0000
+++ driver/qtnode.h	2014-07-24 23:49:59 +0000
@@ -6,6 +6,13 @@
 #include <QDBusArgument>
 #include <xpathselect/node.h>
 
+#include <QModelIndex>
+
+class QAbstractItemView;
+class QTableWidgetItem;
+class QTreeView;
+class QTreeWidgetItem;
+
 /// A simple data structure representing the state of a single node:
 struct NodeIntrospectionData
 {
@@ -16,8 +23,8 @@
 Q_DECLARE_METATYPE(NodeIntrospectionData);
 Q_DECLARE_METATYPE(QList<NodeIntrospectionData>);
 
-QDBusArgument &operator<<(QDBusArgument &argument, const NodeIntrospectionData &node_data);
-const QDBusArgument &operator>>(const QDBusArgument &argument, NodeIntrospectionData &node_data);
+QDBusArgument &operator<<(QDBusArgument &argument, NodeIntrospectionData const& node_data);
+const QDBusArgument &operator>>(QDBusArgument const& argument, NodeIntrospectionData &node_data);
 
 // Interface for Introspecting an object to query it's details.
 class DBusNode : public xpathselect::Node
@@ -33,7 +40,7 @@
 
 /// Specialist class for all QObject object nodes.
 /// This will cover a majority of what we use and we will only need to break
-/// out to specilist classes for a couple of minor (i.e. QModelIndex)
+/// out to specialist classes for a couple of minor edge-cases (i.e. QModelIndex)
 ///
 /// QObjectNode wraps a single QObject pointer. It derives from
 /// xpathselect::Node (DBusNode) and, like that class, is designed to be
@@ -56,9 +63,9 @@
     virtual std::string GetName() const;
     virtual std::string GetPath() const;
     virtual int32_t GetId() const;
-    virtual bool MatchStringProperty(const std::string& name, const std::string& value) const;
-    virtual bool MatchIntegerProperty(const std::string& name, int32_t value) const;
-    virtual bool MatchBooleanProperty(const std::string& name, bool value) const;
+    virtual bool MatchStringProperty(std::string const& name, std::string const& value) const;
+    virtual bool MatchIntegerProperty(std::string const& name, int32_t value) const;
+    virtual bool MatchBooleanProperty(std::string const& name, bool value) const;
     virtual xpathselect::NodeVector Children() const;
 
 private:
@@ -67,4 +74,83 @@
     DBusNode::Ptr parent_;
 };
 
+class QModelIndexNode : public DBusNode, public std::enable_shared_from_this<QModelIndexNode>
+{
+public:
+    QModelIndexNode(QModelIndex index, QAbstractItemView* parent_view, DBusNode::Ptr parent);
+
+    // DBusNode
+    virtual NodeIntrospectionData GetIntrospectionData() const;
+
+    // xpathselect::Node
+    xpathselect::Node::Ptr GetParent() const;
+    virtual std::string GetName() const;
+    virtual std::string GetPath() const;
+    virtual int32_t GetId() const;
+    virtual bool MatchStringProperty(std::string const& name, std::string const& value) const;
+    virtual bool MatchIntegerProperty(std::string const& name, int32_t value) const;
+    virtual bool MatchBooleanProperty(std::string const& name, bool value) const;
+    virtual xpathselect::NodeVector Children() const;
+
+private:
+    QVariantMap GetProperties() const;
+
+    QModelIndex index_;
+    QAbstractItemView* parent_view_;
+    std::string full_path_;
+    DBusNode::Ptr parent_;
+};
+
+class QTableWidgetItemNode : public DBusNode, public std::enable_shared_from_this<QTableWidgetItemNode>
+{
+public:
+    QTableWidgetItemNode(QTableWidgetItem *item, DBusNode::Ptr parent);
+
+    // DBusNode
+    virtual NodeIntrospectionData GetIntrospectionData() const;
+
+    // xpathselect::Node
+    xpathselect::Node::Ptr GetParent() const;
+    virtual std::string GetName() const;
+    virtual std::string GetPath() const;
+    virtual int32_t GetId() const;
+    virtual bool MatchStringProperty(std::string const& name, std::string const& value) const;
+    virtual bool MatchIntegerProperty(std::string const& name, int32_t value) const;
+    virtual bool MatchBooleanProperty(std::string const& name, bool value) const;
+    virtual xpathselect::NodeVector Children() const;
+
+private:
+    QVariantMap GetProperties() const;
+
+    QTableWidgetItem *item_;
+    std::string full_path_;
+    DBusNode::Ptr parent_;
+};
+
+class QTreeWidgetItemNode : public DBusNode, public std::enable_shared_from_this<QTreeWidgetItemNode>
+{
+public:
+    QTreeWidgetItemNode(QTreeWidgetItem *item, DBusNode::Ptr parent);
+
+    // DBusNode
+    virtual NodeIntrospectionData GetIntrospectionData() const;
+
+    // xpathselect::Node
+    xpathselect::Node::Ptr GetParent() const;
+    virtual std::string GetName() const;
+    virtual std::string GetPath() const;
+    virtual int32_t GetId() const;
+    virtual bool MatchStringProperty(std::string const& name, std::string const& value) const;
+    virtual bool MatchIntegerProperty(std::string const& name, int32_t value) const;
+    virtual bool MatchBooleanProperty(std::string const& name, bool value) const;
+    virtual xpathselect::NodeVector Children() const;
+
+private:
+    QVariantMap GetProperties() const;
+
+    QTreeWidgetItem *item_;
+    std::string full_path_;
+    DBusNode::Ptr parent_;
+};
+
 #endif // QTNODE_H

=== modified file 'tests/unittests/tst_introspection.cpp'
--- tests/unittests/tst_introspection.cpp	2014-07-24 23:49:59 +0000
+++ tests/unittests/tst_introspection.cpp	2014-07-24 23:49:59 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2014 Canonical, Ltd.
  *
  * Authors:
  *  Michael Zanetti <[e-mail]>
@@ -25,35 +25,13 @@
 #include <QGridLayout>
 #include <QPushButton>
 
+#include "tst_introspection.h"
+
 #include "introspection.h"
 #include "qtnode.h"
 
 QVariant IntrospectNode(QObject* obj);
 
-class tst_Introspection : public QObject
-{
-    Q_OBJECT
-
-private slots:
-    void initTestCase();
-    void cleanupTestCase();
-
-    void test_introspect_data();
-    void test_introspect();
-
-    void test_application_names_data();
-    void test_application_names();
-
-    void test_properties_data();
-    void test_properties();
-
-    void test_property_matching();
-
-private:
-    QMainWindow *m_object;
-};
-
-
 void tst_Introspection::initTestCase()
 {
     QApplication::setApplicationName("tst_introspection");
@@ -510,7 +488,3 @@
     QVERIFY(n.MatchIntegerProperty("myUInt", 5) == true);
     QVERIFY(n.MatchBooleanProperty("visible", true) == true);
 }
-
-QTEST_MAIN(tst_Introspection)
-
-#include "tst_introspection.moc"

=== added file 'tests/unittests/tst_introspection.h'
--- tests/unittests/tst_introspection.h	1970-01-01 00:00:00 +0000
+++ tests/unittests/tst_introspection.h	2014-07-24 23:49:59 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Christopher Lee <[e-mail]>
+ *
+ * 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/>.
+ *
+ */
+
+#include <QMainWindow>
+
+class tst_Introspection : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void initTestCase();
+    void cleanupTestCase();
+
+    void test_introspect_data();
+    void test_introspect();
+
+    void test_application_names_data();
+    void test_application_names();
+
+    void test_properties_data();
+    void test_properties();
+
+    void test_property_matching();
+
+private:
+    QMainWindow *m_object;
+};

=== added file 'tests/unittests/tst_main.cpp'
--- tests/unittests/tst_main.cpp	1970-01-01 00:00:00 +0000
+++ tests/unittests/tst_main.cpp	2014-07-24 23:49:59 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2014 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/>.
+ *
+ */
+
+#include <QTest>
+
+#include "tst_qtnode.h"
+#include "tst_introspection.h"
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+
+    tst_Introspection introspection_tc;
+    tst_qtnode qtnode_tc;
+    return QTest::qExec(&introspection_tc, argc, argv) || QTest::qExec(&qtnode_tc, argc, argv);
+}

=== added file 'tests/unittests/tst_qtnode.cpp'
--- tests/unittests/tst_qtnode.cpp	1970-01-01 00:00:00 +0000
+++ tests/unittests/tst_qtnode.cpp	2014-07-24 23:49:59 +0000
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Christopher Lee <[e-mail]>
+ *
+ * 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/>.
+ *
+ */
+
+#include <QtTest>
+
+#include <QTreeView>
+#include <QTreeWidget>
+#include <QTableWidget>
+#include <QListView>
+#include <QModelIndex>
+#include <QStandardItemModel>
+
+#include "tst_qtnode.h"
+
+#include "introspection.h"
+#include "qtnode.h"
+
+int32_t calculate_ap_id(quint64 big_id);
+void CollectSpecialChildren(QObject* object, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void CollectAllIndices(QModelIndex index, QAbstractItemModel *model, QModelIndexList &collection);
+bool MatchProperty(const QVariantMap& packed_properties, const std::string& name, QVariant value);
+
+void GetDataElementChildren(QTableWidget* table, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void GetDataElementChildren(QTreeView* tree_view, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void GetDataElementChildren(QTreeWidget* tree_widget, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void GetDataElementChildren(QListView* list_view, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+
+
+void tst_qtnode::initTestCase()
+{
+    QApplication::setApplicationName("tst_qtnode");
+}
+
+void tst_qtnode::test_calculate_ap_id_data()
+{
+    QTest::addColumn<quint64>("id");
+    QTest::addColumn<int32_t>("expected_result");
+
+    QTest::newRow("1") << Q_UINT64_C(0xFFFFFFFF) << int(0xFFFFFFFF);
+    QTest::newRow("2") << Q_UINT64_C(0x00000000FFFFFFFF) << int(0xFFFFFFFF);
+    QTest::newRow("3") << Q_UINT64_C(0xFFFFFFFFFFFFFFFF) << int(0x0);
+    QTest::newRow("4") << Q_UINT64_C(0x0F0F0F0F0F0F0F0F) << int(0x0);
+    QTest::newRow("5") << Q_UINT64_C(0xF0F0F0FF0F0F0F0) << int(0xFFFFFFFF);
+    QTest::newRow("6") << Q_UINT64_C(0xF0F0F0F0FFFFFFFF) << int(0xF0F0F0F);
+}
+
+void tst_qtnode::test_calculate_ap_id()
+{
+    QFETCH(quint64, id);
+    QFETCH(int32_t, expected_result);
+
+    QCOMPARE(calculate_ap_id(id), expected_result);
+}
+
+void tst_qtnode::test_CollectAllIndices_collects_all_table_data()
+{
+    int row_count = 2;
+    int col_count = 2;
+    testModel = std::make_shared<QStandardItemModel>(row_count, col_count);
+
+    for (int row = 0; row < row_count; ++row) {
+        for (int column = 0; column < col_count; ++column) {
+            QStandardItem *item = new QStandardItem(
+                QString("row %0, column %1").arg(row).arg(column));
+            testModel->setItem(row, column, item);
+        }
+    }
+}
+
+void tst_qtnode::test_CollectAllIndices_collects_all_table()
+{
+    QModelIndexList collection;
+    QStandardItem *root_item = testModel->invisibleRootItem();
+    CollectAllIndices(root_item->index(), testModel.get(), collection);
+
+    QCOMPARE(collection.size(), 4);
+}
+
+void tst_qtnode::test_CollectAllIndices_collects_all_list_data()
+{
+    int listitem_count = 4;
+    testModel = std::make_shared<QStandardItemModel>();
+    QStandardItem *parentItem = testModel->invisibleRootItem();
+    for (int i = 0; i < listitem_count; ++i) {
+        QStandardItem *item = new QStandardItem(QString("item %0").arg(i));
+        parentItem->appendRow(item);
+        parentItem = item;
+    }
+}
+
+void tst_qtnode::test_CollectAllIndices_collects_all_list()
+{
+    QModelIndexList collection;
+    QStandardItem *root_item = testModel->invisibleRootItem();
+    CollectAllIndices(root_item->index(), testModel.get(), collection);
+
+    QCOMPARE(collection.size(), 4);
+}
+
+Q_DECLARE_METATYPE(std::string)
+void tst_qtnode::test_MatchProperty_data()
+{
+    QTest::addColumn<QVariantMap>("packedProperties");
+    QTest::addColumn<std::string>("name");
+    QTest::addColumn<QVariant>("value");
+    QTest::addColumn<bool>("expectedResult");
+
+    QVariantMap p;
+    p["string"] = PackProperty(QVariant("string"));
+    p["int"] = PackProperty(QVariant(1));
+    p["bool"] = PackProperty(QVariant(true));
+
+    QTest::newRow("Matches string") << p << std::string("string") << QVariant("string") << true;
+    QTest::newRow("Matches int") << p << std::string("int") << QVariant(1) << true;
+    QTest::newRow("Matches bool") << p << std::string("bool") << QVariant(true) << true;
+
+    QTest::newRow("Fails not present") << p << std::string("notpresent") << QVariant("string") << false;
+    QTest::newRow("Fails values do not match")
+        << p
+        << std::string("string")
+        << QVariant("notstring")
+        << false;
+}
+
+void tst_qtnode::test_MatchProperty()
+{
+    QFETCH(QVariantMap, packedProperties);
+    QFETCH(std::string, name);
+    QFETCH(QVariant, value);
+    QFETCH(bool, expectedResult);
+
+    QCOMPARE(MatchProperty(packedProperties, name, value), expectedResult);
+}
+
+void tst_qtnode::populate_QTreeView_with_data()
+{
+    testModel = std::make_shared<QStandardItemModel>();
+    testModel->setColumnCount(1);
+    testModel->setRowCount(5);
+    testModel->setData(testModel->index(0, 0), "test0");
+    testModel->setData(testModel->index(1, 0), "test1");
+    testModel->setData(testModel->index(2, 0), "test2");
+    testModel->setData(testModel->index(3, 0), "test3");
+    testModel->setData(testModel->index(4, 0), "test4");
+
+    treeView = std::make_shared<QTreeView>();
+    treeView->setModel(testModel.get());
+}
+
+void tst_qtnode::populate_QTreeWidget_with_data()
+{
+    treeWidget = std::make_shared<QTreeWidget>();
+    treeWidget->setColumnCount(1);
+    QList<QTreeWidgetItem *> items;
+    for (int i = 0; i < 5; ++i)
+        items.append(new QTreeWidgetItem());
+    treeWidget->insertTopLevelItems(0, items);
+}
+
+void tst_qtnode::populate_QListView_with_data()
+{
+    testModel = std::make_shared<QStandardItemModel>();
+    testModel->setColumnCount(1);
+    testModel->setRowCount(5);
+    testModel->setData(testModel->index(0, 0), "test0");
+    testModel->setData(testModel->index(1, 0), "test1");
+    testModel->setData(testModel->index(2, 0), "test2");
+    testModel->setData(testModel->index(3, 0), "test3");
+    testModel->setData(testModel->index(4, 0), "test4");
+
+    listView = std::make_shared<QListView>();
+    listView->setModel(testModel.get());
+}
+
+void tst_qtnode::populate_QTableWidget_with_data()
+{
+    tableWidget = std::make_shared<QTableWidget>();
+    tableWidget->setRowCount(4);
+    tableWidget->setColumnCount(2);
+
+    for (int row = 0; row < 4; ++row) {
+        for (int column = 0; column < 2; ++column) {
+            tableWidget->setItem(row, column, new QTableWidgetItem());
+        }
+    }
+}
+
+void tst_qtnode::test_GetDataElementChildren_QTreeView_collects_all_data()
+{
+    populate_QTreeView_with_data();
+}
+
+void tst_qtnode::test_GetDataElementChildren_QTreeView_collects_all()
+{
+    xpathselect::NodeVector children;
+    DBusNode::Ptr parent;
+
+    GetDataElementChildren(treeView.get(), children, parent);
+
+    QCOMPARE((int)children.size(), 5);
+
+    auto node_parent = children[0]->GetParent();
+    QVERIFY(node_parent == parent);
+}
+
+void tst_qtnode::test_GetDataElementChildren_QTreeWidget_collects_all_data()
+{
+    populate_QTreeWidget_with_data();
+}
+
+void tst_qtnode::test_GetDataElementChildren_QTreeWidget_collects_all()
+{
+    xpathselect::NodeVector children;
+    DBusNode::Ptr parent;
+    GetDataElementChildren(treeWidget.get(), children, parent);
+
+    QCOMPARE((int)children.size(), 5);
+
+    auto node_parent = children[0]->GetParent();
+    QVERIFY(node_parent == parent);
+}
+
+void tst_qtnode::test_GetDataElementChildren_QListView_collects_all_data()
+{
+    populate_QListView_with_data();
+}
+
+void tst_qtnode::test_GetDataElementChildren_QListView_collects_all()
+{
+    xpathselect::NodeVector children;
+    DBusNode::Ptr parent;
+
+    GetDataElementChildren(listView.get(), children, parent);
+
+    QCOMPARE((int)children.size(), 5);
+
+    auto node_parent = children[0]->GetParent();
+    QVERIFY(node_parent == parent);
+}
+
+void tst_qtnode::test_GetDataElementChildren_QTableWidget_collects_all_data()
+{
+    populate_QTableWidget_with_data();
+}
+
+void tst_qtnode::test_GetDataElementChildren_QTableWidget_collects_all()
+{
+    xpathselect::NodeVector children;
+    DBusNode::Ptr parent;
+
+    GetDataElementChildren(tableWidget.get(), children, parent);
+
+    QCOMPARE((int)children.size(), 8);
+
+    auto node_parent = children[0]->GetParent();
+    QVERIFY(node_parent == parent);
+}
+
+void tst_qtnode::test_CollectSpecialChildren_QTreeView_collects_all_data()
+{
+    populate_QTreeView_with_data();
+}
+
+void tst_qtnode::test_CollectSpecialChildren_QTreeView_collects_all()
+{
+    xpathselect::NodeVector children;
+    DBusNode::Ptr parent;
+
+    CollectSpecialChildren(treeView.get(), children, parent);
+
+    QCOMPARE((int)children.size(), 5);
+}
+
+void tst_qtnode::test_CollectSpecialChildren_QTreeWidget_collects_all_data()
+{
+    populate_QTreeWidget_with_data();
+}
+
+void tst_qtnode::test_CollectSpecialChildren_QTreeWidget_collects_all()
+{
+    xpathselect::NodeVector children;
+    DBusNode::Ptr parent;
+
+    CollectSpecialChildren(treeWidget.get(), children, parent);
+
+    QCOMPARE((int)children.size(), 5);
+}
+
+void tst_qtnode::test_CollectSpecialChildren_QListView_collects_all_data()
+{
+    populate_QListView_with_data();
+}
+
+void tst_qtnode::test_CollectSpecialChildren_QListView_collects_all()
+{
+    xpathselect::NodeVector children;
+    DBusNode::Ptr parent;
+
+    CollectSpecialChildren(listView.get(), children, parent);
+
+    QCOMPARE((int)children.size(), 5);
+}
+
+void tst_qtnode::test_CollectSpecialChildren_QTableWidget_collects_all_data()
+{
+    populate_QTableWidget_with_data();
+}
+
+void tst_qtnode::test_CollectSpecialChildren_QTableWidget_collects_all()
+{
+    xpathselect::NodeVector children;
+    DBusNode::Ptr parent;
+
+    CollectSpecialChildren(tableWidget.get(), children, parent);
+
+    QCOMPARE((int)children.size(), 8);
+}
+
+void tst_qtnode::test_CollectSpecialChildren_QObject_collects_nothing()
+{
+    xpathselect::NodeVector children;
+    DBusNode::Ptr parent;
+    std::shared_ptr<QObject> testObject = std::make_shared<QObject>();
+
+    CollectSpecialChildren(testObject.get(), children, parent);
+
+    QCOMPARE((int)children.size(), 0);
+}

=== added file 'tests/unittests/tst_qtnode.h'
--- tests/unittests/tst_qtnode.h	1970-01-01 00:00:00 +0000
+++ tests/unittests/tst_qtnode.h	2014-07-24 23:49:59 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Christopher Lee <[e-mail]>
+ *
+ * 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/>.
+ *
+ */
+
+#include <memory>
+
+#include <QObject>
+
+class QStandardItemModel;
+class QStandardItemModel;
+class QTreeWidget;
+class QListView;
+class QTreeView;
+class QTableWidget;
+
+class tst_qtnode: public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void initTestCase();
+    void test_calculate_ap_id_data();
+    void test_calculate_ap_id();
+
+    void test_CollectAllIndices_collects_all_table_data();
+    void test_CollectAllIndices_collects_all_table();
+    void test_CollectAllIndices_collects_all_list_data();
+    void test_CollectAllIndices_collects_all_list();
+
+    void test_MatchProperty_data();
+    void test_MatchProperty();
+
+    void populate_QTreeView_with_data();
+    void populate_QTreeWidget_with_data();
+    void populate_QListView_with_data();
+    void populate_QTableWidget_with_data();
+
+    void test_GetDataElementChildren_QTreeView_collects_all_data();
+    void test_GetDataElementChildren_QTreeView_collects_all();
+    void test_GetDataElementChildren_QTreeWidget_collects_all_data();
+    void test_GetDataElementChildren_QTreeWidget_collects_all();
+    void test_GetDataElementChildren_QListView_collects_all_data();
+    void test_GetDataElementChildren_QListView_collects_all();
+    void test_GetDataElementChildren_QTableWidget_collects_all_data();
+    void test_GetDataElementChildren_QTableWidget_collects_all();
+
+    void test_CollectSpecialChildren_QTreeView_collects_all_data();
+    void test_CollectSpecialChildren_QTreeView_collects_all();
+    void test_CollectSpecialChildren_QTreeWidget_collects_all_data();
+    void test_CollectSpecialChildren_QTreeWidget_collects_all();
+    void test_CollectSpecialChildren_QListView_collects_all_data();
+    void test_CollectSpecialChildren_QListView_collects_all();
+    void test_CollectSpecialChildren_QTableWidget_collects_all_data();
+    void test_CollectSpecialChildren_QTableWidget_collects_all();
+    void test_CollectSpecialChildren_QObject_collects_nothing();
+private:
+    std::shared_ptr<QStandardItemModel> testModel;
+    std::shared_ptr<QTreeWidget> treeWidget;
+    std::shared_ptr<QListView> listView;
+    std::shared_ptr<QTreeView> treeView;
+    std::shared_ptr<QTableWidget> tableWidget;
+};

=== modified file 'tests/unittests/unittests.pro'
--- tests/unittests/unittests.pro	2013-08-29 02:36:52 +0000
+++ tests/unittests/unittests.pro	2014-07-24 23:49:59 +0000
@@ -1,7 +1,7 @@
 #include(../../coverage.pri)
 
 CONFIG += testcase
-TARGET = tst_introspection
+TARGET = tst_libautopilot-qt
 
 QT += testlib dbus widgets quick
 
@@ -16,12 +16,16 @@
 INCLUDEPATH += ../../driver
 
 SOURCES += \
+	tst_main.cpp \
+	tst_qtnode.cpp \
 	tst_introspection.cpp \
     ../../driver/introspection.cpp \
     ../../driver/rootnode.cpp \
     ../../driver/qtnode.cpp
 
 HEADERS += \
+    tst_qtnode.h \
+    tst_introspection.h \
     ../../driver/introspection.h \
     ../../driver/rootnode.h \
     ../../driver/qtnode.h