Merge lp:~autopilot/autopilot-qt/experimental into lp:autopilot-qt

[Thomi Richards]

1.4 wire protocol changes.

Merge 1.4 changes.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:84
http://jenkins.qa.ubuntu.com/job/autopilot-qt-ci/70/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-qt-saucy-amd64-ci/12/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-qt-saucy-armhf-ci/12/console

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

review: Needs Fixing (continuous-integration)

[lp:~autopilot/autopilot-qt/experimental]

85. By Thomi Richards on 2013-09-16

Add Breaks clause on binary package.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:85
http://jenkins.qa.ubuntu.com/job/autopilot-qt-ci/71/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-saucy-amd64-ci/13
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-qt-saucy-armhf-ci/13
        deb: http://jenkins.qa.ubuntu.com/job/autopilot-qt-saucy-armhf-ci/13/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

=== modified file 'debian/changelog'
--- debian/changelog	2013-08-14 02:04:35 +0000
+++ debian/changelog	2013-09-16 18:00:39 +0000
@@ -1,3 +1,10 @@
+autopilot-qt (1.4-0ubuntu1) saucy; urgency=low
+
+  [ Thomi Richards ]
+  * Update to new xpathselect 1.4 API. Version bump to 1.4.
+
+ -- Thomi Richards <[e-mail]>  Thu, 15 Aug 2013 11:23:33 +1200
+
 autopilot-qt (1.3+13.10.20130814-0ubuntu1) saucy; urgency=low
 
   [ Robert Bruce Park ]
 
=== modified file 'debian/control'
--- debian/control	2013-08-13 22:39:44 +0000
+++ debian/control	2013-09-16 18:00:39 +0000
@@ -6,7 +6,7 @@
                libgl1-mesa-dev,
                libgles2-mesa-dev,
                libqt4-dev,
-               libxpathselect-dev (>= 1.3),
+               libxpathselect-dev (>= 1.4),
                mesa-common-dev,
                pkg-config,
                qt4-qmake,
@@ -27,9 +27,11 @@
 Package: libautopilot-qt
 Section: libs
 Architecture: any
-Depends: libxpathselect1.3,
+Depends: libxpathselect1.4,
          ${misc:Depends},
          ${shlibs:Depends},
+Breaks: python-autopilot (<< 1.4),
+        python3-autopilot (<< 1.4)
 Replaces: autopilot-qt,
           autopilot-qt5,
 Conflicts: autopilot-qt,
 
=== added file 'driver/autopilot_types.h'
--- driver/autopilot_types.h	1970-01-01 00:00:00 +0000
+++ driver/autopilot_types.h	2013-09-16 18:00:39 +0000
@@ -0,0 +1,26 @@
+/*
+Copyright 2012 Canonical
+
+This program is free software: you can redistribute it and/or modify it
+under the terms of the GNU General Public License version 3, as published
+by the Free Software Foundation.
+*/
+
+
+#ifndef AUTOPILOT_TYPES_H
+#define AUTOPILOT_TYPES_H
+
+/// IMPORTANT: THese constants are taken from the autopilot XPathSelect protocol document.
+/// Only add options here if the support has been added for them in autopilot itself.
+enum autopilot_type_id
+{
+    TYPE_PLAIN = 0,
+    TYPE_RECT = 1,
+    TYPE_POINT = 2,
+    TYPE_SIZE = 3,
+    TYPE_COLOR = 4,
+    TYPE_DATETIME = 5,
+    TYPE_TIME = 6,
+};
+
+#endif
 
=== modified file 'driver/dbus_adaptor.cpp'
--- driver/dbus_adaptor.cpp	2013-05-07 23:46:49 +0000
+++ driver/dbus_adaptor.cpp	2013-09-16 18:00:39 +0000
@@ -51,7 +51,7 @@
 void AutopilotAdaptor::GetVersion(const QDBusMessage &message)
 {
     QDBusMessage reply =  message.createReply();
-    reply << QVariant(QString("1.3"));
+    reply << QVariant(QString("1.4"));
     QDBusConnection::sessionBus().send(reply);
 }
 
 
=== modified file 'driver/dbus_object.cpp'
--- driver/dbus_object.cpp	2013-06-27 16:27:11 +0000
+++ driver/dbus_object.cpp	2013-09-16 18:00:39 +0000
@@ -294,10 +294,12 @@
 void DBusObject::ProcessQuery()
 {
     Query query = _queries.takeFirst();
-    QList<QVariant> state = Introspect(query.first);
+    QList<NodeIntrospectionData> state = Introspect(query.first);
 
     QDBusMessage msg = query.second;
-    msg << QVariant(state);
+    QVariant var;
+    var.setValue(state);
+    msg << var;
 
     QDBusConnection::sessionBus().send(msg);
 }
 
=== modified file 'driver/driver.pro'
--- driver/driver.pro	2013-01-17 20:20:44 +0000
+++ driver/driver.pro	2013-09-16 18:00:39 +0000
@@ -29,7 +29,8 @@
           rootnode.h \
           qtnode.h \
           introspection.h \
-          dbus_adaptor_qt.h
+          dbus_adaptor_qt.h \
+          autopilot_types.h
 
 target.file = libtestability*
 
 
=== modified file 'driver/introspection.cpp'
--- driver/introspection.cpp	2013-06-26 09:00:13 +0000
+++ driver/introspection.cpp	2013-09-16 18:00:39 +0000
@@ -37,6 +37,7 @@
 #include <QUrl>
 #include <QDateTime>
 
+#include "autopilot_types.h"
 #include "introspection.h"
 #include "qtnode.h"
 #include "rootnode.h"
@@ -47,13 +48,13 @@
 QStringList GetNodeChildNames(QObject* obj);
 void AddCustomProperties(QObject* obj, QVariantMap& properties);
 
-QList<QVariant> Introspect(QString const& query_string)
+QList<NodeIntrospectionData> Introspect(QString const& query_string)
 {
-    QList<QVariant> state;
+    QList<NodeIntrospectionData> state;
     QList<QtNode::Ptr> node_list = GetNodesThatMatchQuery(query_string);
     foreach (QtNode::Ptr obj, node_list)
     {
-        state.append(obj->IntrospectNode());
+        state.append(obj->GetIntrospectionData());
     }
 
     return state;
@@ -85,11 +86,11 @@
 #endif
     QList<QtNode::Ptr> node_list;
 
-    xpathselect::NodeList list = xpathselect::SelectNodes(root, query_string.toStdString());
+    xpathselect::NodeVector list = xpathselect::SelectNodes(root, query_string.toStdString());
     for (auto node : list)
     {
         // node may be our root node wrapper *or* an ordinary qobject wrapper
-        auto object_ptr = std::static_pointer_cast<QtNode>(node);
+        auto object_ptr = std::static_pointer_cast<const QtNode>(node);
         if (object_ptr)
         {
             node_list.append(object_ptr);
@@ -154,7 +155,7 @@
     // add the 'Children' pseudo-property:
     QStringList children = GetNodeChildNames(obj);
     if (!children.empty())
-        object_properties["Children"] = children;
+        object_properties["Children"] = PackProperty(children);
 
     return object_properties;
 }
@@ -211,69 +212,105 @@
     case QVariant::StringList:
     case QVariant::Double:
     {
-        return prop;
+        return QList<QVariant> {
+            QVariant(TYPE_PLAIN),
+            prop
+        };
     }
 
     case QVariant::ByteArray:
     {
-        return QVariant(QString(qvariant_cast<QByteArray>(prop)));
+        return QList<QVariant> {
+            QVariant(TYPE_PLAIN),
+            QVariant(QString(qvariant_cast<QByteArray>(prop)))
+        };
     }
 
     case QVariant::Point:
     {
         QPoint p = qvariant_cast<QPoint>(prop);
-        QList<QVariant> l = {QVariant(p.x()), QVariant(p.y())};
-        return QVariant(l);
+        return QList<QVariant> {
+            QVariant(TYPE_POINT),
+            QVariant(p.x()),
+            QVariant(p.y())
+        };
     }
 
     case QVariant::Rect:
     {
         QRect r = qvariant_cast<QRect>(prop);
-        QList<QVariant> l = {
+        return QList<QVariant> {
+            QVariant(TYPE_RECT),
             QVariant(r.x()),
             QVariant(r.y()),
             QVariant(r.width()),
             QVariant(r.height()) };
-        return QVariant(l);
     }
 
     case QVariant::Size:
     {
         QSize s = qvariant_cast<QSize>(prop);
-        QList<QVariant> l = { QVariant(s.width()), QVariant(s.height()) };
-        return QVariant(l);
+        return QList<QVariant> {
+            QVariant(TYPE_SIZE),
+            QVariant(s.width()),
+            QVariant(s.height())
+        };
     }
 
     case QVariant::Color:
     {
         QColor color = qvariant_cast<QColor>(prop).toRgb();
-        QList<QVariant> l = { QVariant(color.red()),
-                              QVariant(color.green()),
-                              QVariant(color.blue()),
-                              QVariant(color.alpha())
-                            };
-        return QVariant(l);
+        return QList<QVariant> {
+            QVariant(TYPE_COLOR),
+            QVariant(color.red()),
+            QVariant(color.green()),
+            QVariant(color.blue()),
+            QVariant(color.alpha())
+        };
     }
 
     case QVariant::Url:
     {
-        return QVariant(prop.toUrl().toString());
+        return QList<QVariant> {
+            QVariant(TYPE_PLAIN),
+            QVariant(prop.toUrl().toString())
+        };
     }
 
     // Depending on the architecture, floating points might be of type QMetaType::Float instead of QVariant::Double
     // QDBus however, can only carry QVariant types, so lets convert it to QVariant::Double
     case QMetaType::Float:
     {
-        return QVariant(prop.toDouble());
+        return QList<QVariant> {
+            QVariant(TYPE_PLAIN),
+            QVariant(prop.toDouble())
+        };
     }
+
     case QVariant::Date:
     case QVariant::DateTime:
-        return QVariant(prop.toDateTime().toTime_t());
+    {
+        return QList<QVariant> {
+            QVariant(TYPE_DATETIME),
+            QVariant(prop.toDateTime().toTime_t())
+        };
+    }
+
     case QVariant::Time:
-        return QVariant(prop.toTime().toString("hh:mm:ss"));
+    {
+        QTime t = qvariant_cast<QTime>(prop);
+        return QList<QVariant> {
+            QVariant(TYPE_TIME),
+            QVariant(t.hour()),
+            QVariant(t.minute()),
+            QVariant(t.second()),
+            QVariant(t.msec())
+        };
+    }
+
     default:
     {
-        return QVariant();
+        return QVariant(); // unsupported type, will not be sent to the client.
     }
     }
 }
 
=== modified file 'driver/introspection.h'
--- driver/introspection.h	2012-08-23 22:01:03 +0000
+++ driver/introspection.h	2013-09-16 18:00:39 +0000
@@ -14,7 +14,7 @@
 #include <QVariantMap>
 
 /// Introspect 'obj' and return it's properties in a QVariantMap.
-QList<QVariant> Introspect(const QString& query_string);
+QList<NodeIntrospectionData> Introspect(const QString& query_string);
 
 /// Get a list of QtNode pointers that match the given query.
 QList<QtNode::Ptr> GetNodesThatMatchQuery(QString const& query_string);
 
=== modified file 'driver/qtnode.cpp'
--- driver/qtnode.cpp	2013-06-19 10:56:21 +0000
+++ driver/qtnode.cpp	2013-09-16 18:00:39 +0000
@@ -15,41 +15,54 @@
   #include <QGraphicsScene>
   #include <QGraphicsObject>
 #endif
+#include <QDBusArgument>
+
+// Marshall the NodeIntrospectionData data into a D-Bus argument
+ QDBusArgument &operator<<(QDBusArgument &argument, const NodeIntrospectionData &node_data)
+ {
+     argument.beginStructure();
+     argument << node_data.object_path << node_data.state;
+     argument.endStructure();
+     return argument;
+ }
+
+ // Retrieve the NodeIntrospectionData data from the D-Bus argument
+ const QDBusArgument &operator>>(const QDBusArgument &argument, NodeIntrospectionData &node_data)
+ {
+     argument.beginStructure();
+     argument >> node_data.object_path >> node_data.state;
+     argument.endStructure();
+     return argument;
+ }
 
 const QByteArray AP_ID_NAME("_autopilot_id");
 
-QtNode::QtNode(QObject *obj, std::string const& parent_path)
-    : object_(obj)
+QtNode::QtNode(QObject *obj, QtNode::Ptr parent)
+: object_(obj)
+, parent_(parent)
 {
+    std::string parent_path = parent ? parent->GetPath() : "";
     full_path_ = parent_path + "/" + GetName();
 }
 
+QtNode::QtNode(QObject* obj)
+: object_(obj)
+{
+    full_path_ = "/" + GetName();
+}
+
 QObject* QtNode::getWrappedObject() const
 {
     return object_;
 }
 
-QVariant QtNode::IntrospectNode() const
-{
-    // return must be (name, state_map)
-    QString object_name = QString::fromStdString(GetPath());
-    QVariantMap object_properties = GetNodeProperties(object_);
-    object_properties["id"] = GetObjectId();
-    QList<QVariant> object_tuple = { QVariant(object_name), QVariant(object_properties) };
-    return QVariant(object_tuple);
-}
-
-qint64 QtNode::GetObjectId() const
-{
-    // Note: This starts at 1 for a reason - 1 is reserved for the pseudo root node, and
-    // so must never be allocated to a regular object.
-    static qint64 next_id=1;
-
-    QList<QByteArray> property_names = object_->dynamicPropertyNames();
-    if (!property_names.contains(AP_ID_NAME))
-        object_->setProperty(AP_ID_NAME, QVariant(++next_id));
-    return object_->property(AP_ID_NAME).toLongLong();
-
+NodeIntrospectionData QtNode::GetIntrospectionData() const
+{
+    NodeIntrospectionData data;
+    data.object_path = QString::fromStdString(GetPath());
+    data.state = GetNodeProperties(object_);
+    data.state["id"] = PackProperty(GetId());
+    return data;
 }
 
 std::string QtNode::GetName() const
@@ -68,30 +81,86 @@
     return full_path_;
 }
 
-bool QtNode::MatchProperty(const std::string& name, const std::string& value) const
+int32_t QtNode::GetId() const
+{
+    // Note: This method is used to assign ids to both the root node (with a QApplication object) and
+    // child nodes. This used to be separate code, but now that we export QApplication properties,
+    // we can use this one method everywhere.
+    static int32_t next_id=0;
+
+    QList<QByteArray> property_names = object_->dynamicPropertyNames();
+    if (!property_names.contains(AP_ID_NAME))
+    {
+        int32_t new_id = ++next_id;
+        object_->setProperty(AP_ID_NAME, QVariant(new_id));
+    }
+    return qvariant_cast<int32_t>(object_->property(AP_ID_NAME));
+}
+
+bool QtNode::MatchStringProperty(const std::string& name, const std::string& 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;
+}
+
+bool QtNode::MatchIntegerProperty(const std::string& name, int32_t value) const
 {
     if (name == "id")
-        return QString::fromStdString(value).toLongLong() == GetObjectId();
-    QVariantMap properties = GetNodeProperties(object_);
-
-    QString qname = QString::fromStdString(name);
-    if (! properties.contains(qname))
-        return false;
-
-    QVariant object_value = properties[qname];
-    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;
-}
-
-xpathselect::NodeList QtNode::Children() const
-{
-    xpathselect::NodeList children;
+        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 QtNode::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;
+}
+
+xpathselect::NodeVector QtNode::Children() const
+{
+    xpathselect::NodeVector children;
 
 #ifdef QT5_SUPPORT
     // Qt5's hierarchy for QML has changed a bit:
@@ -101,21 +170,21 @@
 
     QQuickView *view = qobject_cast<QQuickView*>(object_);
     if (view && view->rootObject() != 0) {
-        children.push_back(std::make_shared<QtNode>(view->rootObject(), GetPath()));
+        children.push_back(std::make_shared<QtNode>(view->rootObject(), shared_from_this()));
     }
 
     QQuickItem* item = qobject_cast<QQuickItem*>(object_);
     if (item) {
         foreach (QQuickItem *childItem, item->childItems()) {
             if (childItem->parentItem() == item) {
-                children.push_back(std::make_shared<QtNode>(childItem, GetPath()));
+                children.push_back(std::make_shared<QtNode>(childItem, shared_from_this()));
             }
         }
     } else {
         foreach (QObject *child, object_->children())
         {
             if (child->parent() == object_)
-                children.push_back(std::make_shared<QtNode>(child, GetPath()));
+                children.push_back(std::make_shared<QtNode>(child, shared_from_this()));
         }
     }
 
@@ -123,7 +192,7 @@
     foreach (QObject *child, object_->children())
     {
         if (child->parent() == object_)
-            children.push_back(std::make_shared<QtNode>(child, GetPath()));
+            children.push_back(std::make_shared<QtNode>(child, shared_from_this()));
     }
 
     // If our wrapped object is a QGraphicsScene, we need to explicitly grab any child graphics
@@ -137,10 +206,16 @@
         {
             QGraphicsObject *obj = item->toGraphicsObject();
             if (obj && ! obj->parent())
-                children.push_back(std::make_shared<QtNode>(obj, GetPath()));
+                children.push_back(std::make_shared<QtNode>(obj, shared_from_this()));
         }
     }
 #endif
 
     return children;
 }
+
+
+xpathselect::Node::Ptr QtNode::GetParent() const
+{
+    return parent_;
+}
 
=== modified file 'driver/qtnode.h'
--- driver/qtnode.h	2013-04-18 03:44:31 +0000
+++ driver/qtnode.h	2013-09-16 18:00:39 +0000
@@ -1,33 +1,54 @@
 #ifndef QTNODE_H
 #define QTNODE_H
 
+#include <cstdint>
 #include <QVariant>
+#include <QDBusArgument>
 #include <xpathselect/node.h>
 
+/// A simple data structure representing the state of a single node:
+struct NodeIntrospectionData
+{
+    QString object_path;
+    QVariantMap state;
+};
+
+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);
+
 /// Base class for all Qt-based object nodes.
 ///
 /// QtNode wraps a single QObject pointer. It derives from xpathselect::Node and,
 /// like that class, is designed to be allocated on the heap and stored in a
 /// std::shared_ptr.
-class QtNode: public xpathselect::Node
+class QtNode: public xpathselect::Node, public std::enable_shared_from_this<QtNode>
 {
 public:
-    typedef std::shared_ptr<QtNode> Ptr;
+    typedef std::shared_ptr<const QtNode> Ptr;
 
-    QtNode(QObject* object, std::string const& parent_path);
+    QtNode(QObject* object, Ptr parent);
+    explicit QtNode(QObject* object);
 
     QObject* getWrappedObject() const;
-
-    virtual QVariant IntrospectNode() const;
-    virtual qint64 GetObjectId() const;
+    xpathselect::Node::Ptr GetParent() const;
+
+    virtual NodeIntrospectionData GetIntrospectionData() const;
+
 
     virtual std::string GetName() const;
     virtual std::string GetPath() const;
-    virtual bool MatchProperty(const std::string& name, const std::string& value) const;
-    virtual xpathselect::NodeList Children() 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 xpathselect::NodeVector Children() const;
 private:
     QObject *object_;
     std::string full_path_;
+    Ptr parent_;
 };
 
 #endif // QTNODE_H
 
=== modified file 'driver/qttestability.cpp'
--- driver/qttestability.cpp	2012-12-19 12:27:25 +0000
+++ driver/qttestability.cpp	2013-09-16 18:00:39 +0000
@@ -10,6 +10,7 @@
 #include "dbus_adaptor.h"
 #include "dbus_adaptor_qt.h"
 #include "dbus_object.h"
+#include "qtnode.h"
 
 #include <QCoreApplication>
 #include <QDebug>
@@ -20,6 +21,8 @@
 void qt_testability_init(void)
 {
     qDebug() << "Loading testability driver.";
+    qDBusRegisterMetaType<NodeIntrospectionData>();
+    qDBusRegisterMetaType<QList<NodeIntrospectionData> >();
 
     DBusObject* obj = new DBusObject;
     new AutopilotAdaptor(obj);
 
=== modified file 'driver/rootnode.cpp'
--- driver/rootnode.cpp	2013-04-18 04:46:44 +0000
+++ driver/rootnode.cpp	2013-09-16 18:00:39 +0000
@@ -1,35 +1,32 @@
 #include "rootnode.h"
+#include "introspection.h"
 
 #include <QObject>
 #include <QCoreApplication>
 #include <QStringList>
+#include <QDebug>
 
 RootNode::RootNode(QCoreApplication* application)
-    : QtNode(application, std::string())
+    : QtNode(application)
     , application_(application)
 {
 }
 
-QVariant RootNode::IntrospectNode() const
+
+NodeIntrospectionData RootNode::GetIntrospectionData() const
 {
-    // return must be (name, state_map)
-    QString object_name = QString::fromStdString(GetPath());
+    NodeIntrospectionData data;
+    data.object_path = QString::fromStdString(GetPath());
+    data.state = GetNodeProperties(application_);
     QStringList child_names;
     foreach(QObject* child, children_)
     {
         child_names.append(child->metaObject()->className());
     }
 
-    QVariantMap object_properties;
-    object_properties["Children"] = child_names;
-    object_properties["id"] = GetObjectId();
-    QList<QVariant> object_tuple = { QVariant(object_name), QVariant(object_properties) };
-    return QVariant(object_tuple);
-}
-
-qint64 RootNode::GetObjectId() const
-{
-    return 1;
+    data.state["Children"] = PackProperty(child_names);
+    data.state["id"] = PackProperty(GetId());
+    return data;
 }
 
 void RootNode::AddChild(QObject* child)
@@ -48,18 +45,10 @@
     return "/" + GetName();
 }
 
-bool RootNode::MatchProperty(const std::string& name, const std::string& value) const
-{
-    if (name == "id")
-        return QString::fromStdString(value).toLongLong() == GetObjectId();
-
-    return false;
-}
-
-xpathselect::NodeList RootNode::Children() const
-{
-    xpathselect::NodeList children;
+xpathselect::NodeVector RootNode::Children() const
+{
+    xpathselect::NodeVector children;
     foreach(QObject* child, children_)
-        children.push_back(std::make_shared<QtNode>(child, GetPath()));
+        children.push_back(std::make_shared<QtNode>(child, shared_from_this()));
     return children;
 }
 
=== modified file 'driver/rootnode.h'
--- driver/rootnode.h	2013-04-18 04:46:44 +0000
+++ driver/rootnode.h	2013-09-16 18:00:39 +0000
@@ -13,15 +13,13 @@
 public:
     RootNode(QCoreApplication* application);
 
-    virtual QVariant IntrospectNode() const;
-    virtual qint64 GetObjectId() const;
+    virtual NodeIntrospectionData GetIntrospectionData() const;
 
     void AddChild(QObject* child);
 
     virtual std::string GetName() const;
     virtual std::string GetPath() const;
-    virtual bool MatchProperty(const std::string& name, const std::string& value) const;
-    virtual xpathselect::NodeList Children() const;
+    virtual xpathselect::NodeVector Children() const;
 private:
     QCoreApplication* application_;
     QList<QObject*> children_;
 
=== modified file 'tests/unittests/tst_introspection.cpp'
--- tests/unittests/tst_introspection.cpp	2013-06-26 09:00:13 +0000
+++ tests/unittests/tst_introspection.cpp	2013-09-16 18:00:39 +0000
@@ -26,6 +26,7 @@
 #include <QPushButton>
 
 #include "introspection.h"
+#include "qtnode.h"
 
 QVariant IntrospectNode(QObject* obj);
 
@@ -46,6 +47,8 @@
     void test_properties_data();
     void test_properties();
 
+    void test_property_matching();
+
 private:
     QMainWindow *m_object;
 };
@@ -74,6 +77,7 @@
 
     m_object->setObjectName("testWindow");
     m_object->setProperty("dynamicTestProperty", "testValue");
+    m_object->setProperty("dynamicStringProperty", QString("testValue"));
     m_object->setProperty("myUInt", QVariant(quint8(5)));
     m_object->setProperty("myStringList", QVariant(QStringList() << "string1" << "string2" << "string3"));
     m_object->setProperty("myColor", QColor("red"));
@@ -113,25 +117,155 @@
     QTest::addColumn<QVariant>("firstResultPropertyValue");
 
 #ifdef QT5_SUPPORT
-    QTest::newRow("/") << "/" << 1 << "/tst_introspection" << "Children" << QVariant(QStringList() << "QMainWindow" << "QWidgetWindow");
-    QTest::newRow("//QWidget[id=6]") << "//QWidget[id=6]" << 1 << "/tst_introspection/QMainWindow/QWidget" << "objectName" << QVariant("centralTestWidget");
-    QTest::newRow("//QPushButton[id=9]") << "//QPushButton[id=9]" << 1 << "/tst_introspection/QMainWindow/QWidget/QPushButton" << "objectName" << QVariant("myButton2");
+    QTest::newRow("/")
+        << "/"
+        << 1
+        << "/tst_introspection"
+        << "Children"
+        << QVariant(
+            QVariantList()
+                << 0
+                << QVariant(
+                    QStringList()
+                        << "QMainWindow"
+                        << "QWidgetWindow"
+                    )
+            );
+
+    QTest::newRow("//QWidget[id=6]")
+        << "//QWidget[id=6]"
+        << 1
+        << "/tst_introspection/QMainWindow/QWidget"
+        << "objectName"
+        << QVariant(
+            QVariantList()
+                << 0
+                << "centralTestWidget"
+            );
+
+    QTest::newRow("//QPushButton[id=9]")
+        << "//QPushButton[id=9]"
+        << 1
+        << "/tst_introspection/QMainWindow/QWidget/QPushButton"
+        << "objectName"
+        << QVariant(
+            QVariantList()
+                << 0
+                << "myButton2"
+            );
 #else
-    QTest::newRow("/") << "/" << 1 << "/tst_introspection" << "Children" << QVariant(QStringList() << "QMainWindow");
-    QTest::newRow("//QWidget[id=5]") << "//QWidget[id=5]" << 1 << "/tst_introspection/QMainWindow/QWidget" << "objectName" << QVariant("centralTestWidget");
+    QTest::newRow("/")
+        << "/"
+        << 1
+        << "/tst_introspection"
+        << "Children"
+        << QVariant(
+            QVariantList()
+                << 0
+                << "QMainWindow"
+            );
+
+    QTest::newRow("//QWidget[id=5]")
+        << "//QWidget[id=5]"
+        << 1
+        << "/tst_introspection/QMainWindow/QWidget"
+        << "objectName"
+        << QVariant(
+            QVariantList()
+                << 0
+                << "centralTestWidget"
+            );
 
     // Depending on the environment, Qt4 could add a second QWidget at position 6. That moves other items down by one.
-    if (Introspect("//QWidget[id=6]").count() > 0) {
-        QTest::newRow("//QPushButton[id=9]") << "//QPushButton[id=9]" << 1 << "/tst_introspection/QMainWindow/QWidget/QPushButton" << "objectName" << QVariant("myButton2");
-    } else {
-        QTest::newRow("//QPushButton[id=8]") << "//QPushButton[id=8]" << 1 << "/tst_introspection/QMainWindow/QWidget/QPushButton" << "objectName" << QVariant("myButton2");
+    if (Introspect("//QWidget[id=6]").count() > 0)
+    {
+        QTest::newRow("//QPushButton[id=9]")
+            << "//QPushButton[id=9]"
+            << 1
+            << "/tst_introspection/QMainWindow/QWidget/QPushButton"
+            << "objectName"
+            << QVariant(
+                QVariantList()
+                    << 0
+                    << "myButton2"
+                );
+    }
+    else
+    {
+        QTest::newRow("//QPushButton[id=8]")
+            << "//QPushButton[id=8]"
+            << 1
+            << "/tst_introspection/QMainWindow/QWidget/QPushButton"
+            << "objectName"
+            << QVariant(
+                QVariantList()
+                    << 0
+                    << "myButton2"
+                );
     }
 #endif
 
-    QTest::newRow("//GridLayout") << "//QGridLayout" << 1 << "/tst_introspection/QMainWindow/QWidget/QGridLayout" << "objectName" << QVariant("myTestLayout");
-    QTest::newRow("//QPushButton") << "//QPushButton" << 2 << "/tst_introspection/QMainWindow/QWidget/QPushButton" << "objectName" << QVariant("myButton1");
-    QTest::newRow("//QWidget/*") << "//QWidget/*" << 5 << "/tst_introspection/QMainWindow/QWidget/QGridLayout" << "objectName" << QVariant("myTestLayout");
-    QTest::newRow("broken query") << "broken query" << 0 << QString() << QString() << QVariant();
+    QTest::newRow("/tst_introspection/QMainWindow/QWidget/QGridLayout")
+        << "//QGridLayout"
+        << 1
+        << "/tst_introspection/QMainWindow/QWidget/QGridLayout"
+        << "objectName"
+        << QVariant(
+            QVariantList()
+                << 0
+                << "myTestLayout"
+            );
+
+    QTest::newRow("parent of leaf node")
+        << "/tst_introspection/QMainWindow/QWidget/QGridLayout/.."
+        << 1
+        << "/tst_introspection/QMainWindow/QWidget"
+        << "objectName"
+        << QVariant(
+            QVariantList()
+                << 0
+                << "centralTestWidget"
+            );
+
+    QTest::newRow("parent of root node")
+        << "/tst_introspection/.."
+        << 1
+        << "/tst_introspection"
+        << "id"
+        << QVariant(
+            QVariantList()
+                << 0
+                << 1
+            );
+
+    QTest::newRow("//QPushButton")
+        << "//QPushButton"
+        << 2
+        << "/tst_introspection/QMainWindow/QWidget/QPushButton"
+        << "objectName"
+        << QVariant(
+            QVariantList()
+                << 0
+                << "myButton1"
+            );
+
+    QTest::newRow("//QWidget/*")
+        << "//QWidget/*"
+        << 5
+        << "/tst_introspection/QMainWindow/QWidget/QGridLayout"
+        << "objectName"
+        << QVariant(
+            QVariantList()
+                << 0
+                << "myTestLayout"
+            );
+
+    QTest::newRow("broken query")
+        << "broken query"
+        << 0
+        << QString()
+        << QString()
+        << QVariant();
 }
 
 void tst_Introspection::test_introspect()
@@ -142,16 +276,15 @@
     QFETCH(QString, firstResultPropertyName);
     QFETCH(QVariant, firstResultPropertyValue);
 
-    QList<QVariant> resultList = Introspect(xpath);
+    QList<NodeIntrospectionData> resultList = Introspect(xpath);
 
     QCOMPARE(resultList.count(), resultCount);
 
     if (resultCount > 0) {
-        QVariant firstResult = resultList.first();
-        QVariantMap firstResultProperties = firstResult.toList().last().toMap();
+        NodeIntrospectionData first_object = resultList.first();
 
-        QCOMPARE(firstResult.toList().first().toString(), firstResultType);
-        QCOMPARE(firstResultProperties.value(firstResultPropertyName), firstResultPropertyValue);
+        QCOMPARE(first_object.object_path, firstResultType);
+        QCOMPARE(first_object.state.value(firstResultPropertyName), firstResultPropertyValue);
     }
 }
 
@@ -171,9 +304,9 @@
     qApp->setApplicationName(app_name);
 
 #ifdef QT5_SUPPORT
-    QList<QVariant> result = Introspect("//QWidgetWindow");
+    QList<NodeIntrospectionData> result = Introspect("//QWidgetWindow");
 #else
-    QList<QVariant> result = Introspect("//QMainWindow");
+    QList<NodeIntrospectionData> result = Introspect("//QMainWindow");
 #endif
 
     QVERIFY(!result.isEmpty());
@@ -185,25 +318,169 @@
     QTest::addColumn<QVariant>("propertyValue");
     QTest::addColumn<bool>("fuzzyCompare");
 
-    QTest::newRow("static property") << "objectName" << QVariant(m_object->objectName()) << false;
-    QTest::newRow("dynamic property") << "dynamicTestProperty" << m_object->property("dynamicTestProperty") << false;
-
-    QTest::newRow("int") << "width" << QVariant(m_object->width()) << false;
-    QTest::newRow("uint") << "myUInt" << m_object->property("myUInt") << false;
-    QTest::newRow("bool") << "visible" << QVariant(m_object->isVisible()) << false;
-    QTest::newRow("double") << "windowOpacity" << QVariant(m_object->windowOpacity()) << true;
-
-    QTest::newRow("QString") << "objectName" << QVariant(m_object->objectName()) << false;
-    QTest::newRow("QStringList") << "myStringList" << m_object->property("myStringList") << false;
-    QTest::newRow("QSize") << "maximumSize" << QVariant(QList<QVariant>() << m_object->maximumWidth() << m_object->maximumHeight()) << false;
-    QTest::newRow("QPoint") << "pos" << QVariant(QList<QVariant>() << m_object->x() << m_object->y()) << false;
-    QTest::newRow("QRect") << "geometry" << QVariant(QList<QVariant>() << m_object->geometry().x() << m_object->geometry().y() << m_object->geometry().width() << m_object->geometry().height()) << false;
-    QTest::newRow("QColor") << "myColor" << QVariant(QList<QVariant>() << 255 << 0 << 0 << 255) << false;
-    QTest::newRow("QByteArray") << "myByteArray" << m_object->property("myByteArray") << false;
-    QTest::newRow("QUrl") << "myUrl" << m_object->property("myUrl") << false;
-    QTest::newRow("QDateTime") << "myDateTime" << QVariant(m_object->property("myDateTime").toDateTime().toTime_t()) << false;
-    QTest::newRow("QDate") << "myDate" << QVariant(m_object->property("myDate").toDateTime().toTime_t()) << false;
-    QTest::newRow("QTime") << "myTime" << QVariant(m_object->property("myTime").toTime().toString("hh:mm:ss")) << false;
+    QTest::newRow("static property")
+        << "objectName"
+        << QVariant(
+            QVariantList()
+                << 0
+                << m_object->objectName()
+            )
+        << false;
+
+    QTest::newRow("dynamic property")
+        << "dynamicTestProperty"
+        << QVariant(
+            QVariantList()
+                << 0
+                << m_object->property("dynamicTestProperty")
+            )
+        << false;
+
+    QTest::newRow("int")
+    << "width"
+    << QVariant(
+        QVariantList()
+            << 0
+            << m_object->width()
+        )
+        << false;
+
+    QTest::newRow("uint")
+        << "myUInt"
+        << QVariant(
+            QVariantList()
+                << 0
+                << m_object->property("myUInt")
+            )
+        << false;
+
+    QTest::newRow("bool")
+        << "visible"
+        << QVariant(
+            QVariantList()
+                << 0
+                << m_object->isVisible()
+            )
+        << false;
+
+    QTest::newRow("double")
+        << "windowOpacity"
+        << QVariant(
+            QVariantList()
+                << 0
+                << m_object->windowOpacity()
+            )
+        << true;
+
+    QTest::newRow("QString")
+        << "objectName"
+        << QVariant(
+            QVariantList()
+                << 0
+                << m_object->objectName()
+            )
+        << false;
+
+    QTest::newRow("QStringList")
+        << "myStringList"
+        << QVariant(
+            QVariantList()
+                << 0
+                << m_object->property("myStringList")
+            )
+        << false;
+
+    QTest::newRow("QSize")
+        << "maximumSize"
+        << QVariant(
+            QVariantList()
+                << 3
+                << m_object->maximumWidth()
+                << m_object->maximumHeight()
+            )
+        << false;
+
+    QTest::newRow("QPoint")
+        << "pos"
+        << QVariant(
+            QVariantList()
+                << 2
+                << m_object->x()
+                << m_object->y()
+            )
+        << false;
+
+    QTest::newRow("QRect")
+        << "geometry"
+        << QVariant(
+            QVariantList()
+                << 1
+                << m_object->geometry().x()
+                << m_object->geometry().y()
+                << m_object->geometry().width()
+                << m_object->geometry().height()
+            )
+        << false;
+
+    QTest::newRow("QColor")
+        << "myColor"
+        << QVariant(
+            QVariantList()
+                << 4
+                << qvariant_cast<QColor>(m_object->property("myColor")).red()
+                << qvariant_cast<QColor>(m_object->property("myColor")).green()
+                << qvariant_cast<QColor>(m_object->property("myColor")).blue()
+                << qvariant_cast<QColor>(m_object->property("myColor")).alpha()
+            )
+        << false;
+
+    QTest::newRow("QByteArray")
+        << "myByteArray"
+        << QVariant(
+            QVariantList()
+                << 0
+                << m_object->property("myByteArray")
+            )
+        << false;
+
+    QTest::newRow("QUrl")
+        << "myUrl"
+        << QVariant(
+            QVariantList()
+                << 0
+                << m_object->property("myUrl")
+            )
+        << false;
+
+    QTest::newRow("QDateTime")
+        << "myDateTime"
+        << QVariant(
+            QVariantList()
+                << 5
+                << m_object->property("myDateTime").toDateTime().toTime_t()
+            )
+        << false;
+
+    QTest::newRow("QDate")
+        << "myDate"
+        << QVariant(
+            QVariantList()
+                << 5
+                << m_object->property("myDate").toDateTime().toTime_t()
+            )
+        << false;
+
+    QTest::newRow("QTime")
+        << "myTime"
+        << QVariant(
+            QVariantList()
+                << 6
+                << m_object->property("myTime").toTime().hour()
+                << m_object->property("myTime").toTime().minute()
+                << m_object->property("myTime").toTime().second()
+                << m_object->property("myTime").toTime().msec()
+            )
+        << false;
 }
 
 void tst_Introspection::test_properties()
@@ -224,6 +501,16 @@
     }
 }
 
+void tst_Introspection::test_property_matching()
+{
+    QtNode n(m_object);
+
+    QVERIFY(n.MatchStringProperty("dynamicStringProperty", "testValue") == true);
+    QVERIFY(n.MatchStringProperty("dynamicTestProperty", "testValue") == true);
+    QVERIFY(n.MatchIntegerProperty("myUInt", 5) == true);
+    QVERIFY(n.MatchBooleanProperty("visible", true) == true);
+}
+
 QTEST_MAIN(tst_Introspection)
 
 #include "tst_introspection.moc"
 
=== modified file 'tests/unittests/unittests.pro'
--- tests/unittests/unittests.pro	2013-03-17 16:53:30 +0000
+++ tests/unittests/unittests.pro	2013-09-16 18:00:39 +0000
@@ -5,7 +5,7 @@
 
 QT += testlib dbus widgets quick
 
-CONFIG += link_pkgconfig
+CONFIG += link_pkgconfig debug
 PKGCONFIG += xpathselect
 QMAKE_CXXFLAGS += -std=c++0x -Wl,--no-undefined
 
@@ -15,7 +15,8 @@
 
 INCLUDEPATH += ../../driver
 
-SOURCES += tst_introspection.cpp \
+SOURCES += \
+	tst_introspection.cpp \
     ../../driver/introspection.cpp \
     ../../driver/rootnode.cpp \
     ../../driver/qtnode.cpp