Merge lp:~autopilot/xpathselect/experimental into lp:xpathselect

[Thomi Richards]

XPathSelect type changes and API/ABI bump.

Change for 1.4.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:51
http://jenkins.qa.ubuntu.com/job/xpathselect-ci/5/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/xpathselect-saucy-amd64-ci/1
    SUCCESS: http://jenkins.qa.ubuntu.com/job/xpathselect-saucy-armhf-ci/1

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

review: Approve (continuous-integration)

[Martin Pitt (pitti)]

I didn't re-review every single line of course, but structurally this seems okay. It properly bumps the SONAME and all that, and test coverage is fine.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-04-18 03:29:31 +0000
+++ CMakeLists.txt	2013-09-16 15:53:33 +0000
@@ -6,7 +6,7 @@
 
 include (GNUInstallDirs)
 
-set (VERSION 1.3)
+set (VERSION 1.4)
 
 if(CMAKE_BUILD_TYPE STREQUAL "coverage")
   message("Building for coverage")

=== modified file 'debian/changelog'
--- debian/changelog	2013-06-05 09:01:46 +0000
+++ debian/changelog	2013-09-16 15:53:33 +0000
@@ -1,3 +1,10 @@
+xpathselect (1.4-0ubuntu1) saucy; urgency=low
+
+  [ Thomi Richards ]
+  * New API, bump version to 1.4.
+
+ -- Thomi Richards <[e-mail]>  Thu, 15 Aug 2013 11:08:08 +1200
+
 xpathselect (1.3daily13.06.05.1-0ubuntu1) saucy; urgency=low
 
   [ Thomi Richards ]

=== modified file 'debian/control'
--- debian/control	2013-04-18 03:29:31 +0000
+++ debian/control	2013-09-16 15:53:33 +0000
@@ -20,14 +20,14 @@
 Section: libdevel
 Architecture: any
 Depends: ${misc:Depends},
-         libxpathselect1.3 (= ${binary:Version}),
+         libxpathselect1.4 (= ${binary:Version}),
 Description: Select objects in an object tree using XPath queries - development files
  This library allows you to select arbitrary objects in an object tree using a
  small subset of the XPath specification.
  .
  This package contains development files for xpathselect.
 
-Package: libxpathselect1.3
+Package: libxpathselect1.4
 Section: libs
 Architecture: any
 Multi-Arch: same

=== renamed file 'debian/libxpathselect1.3.install' => 'debian/libxpathselect1.4.install'
=== modified file 'lib/node.h'
--- lib/node.h	2013-04-22 02:18:53 +0000
+++ lib/node.h	2013-09-16 15:53:33 +0000
@@ -20,7 +20,9 @@
 
 #include <string>
 #include <vector>
+#include <list>
 #include <memory>
+#include <cstdint>
 
 namespace xpathselect
 {
@@ -29,7 +31,7 @@
     class Node
     {
     public:
-        typedef std::shared_ptr<Node> Ptr;
+        typedef std::shared_ptr<const Node> Ptr;
 
         /// Get the node's name.
         virtual std::string GetName() const =0;
@@ -37,17 +39,23 @@
         /// Get the node's full path
         virtual std::string GetPath() const =0;
 
-        /// Return true if the node matches the property with the given name & value
-        ///\note: All property values are treated as strings. It is the implementors
-        /// responsibility to convert the value to the appropriate type.
-        virtual bool MatchProperty(const std::string& name, const std::string& value) const =0;
+        /// Get this node's ID.
+        virtual int32_t GetId() const =0;
+
+        virtual bool MatchBooleanProperty(const std::string& name, bool value) const =0;
+        virtual bool MatchIntegerProperty(const std::string& name, int32_t value) const =0;
+        virtual bool MatchStringProperty(const std::string& name, const std::string& value) const =0;
 
         /// Return a list of the children of this node.
         virtual std::vector<Node::Ptr> Children() const =0;
+
+        /// Return a pointer to the parent class.
+        virtual Node::Ptr GetParent() const =0;
     };
 
     /// NodeList is how we return lists of nodes.
-    typedef std::vector<Node::Ptr> NodeList;
+    typedef std::vector<Node::Ptr> NodeVector;
+    typedef std::list<Node::Ptr> NodeList;
 }
 
 #endif

=== modified file 'lib/parser.h'
--- lib/parser.h	2013-04-24 20:38:18 +0000
+++ lib/parser.h	2013-09-16 15:53:33 +0000
@@ -18,12 +18,15 @@
 #define _PARSER_H
 
 #include <string>
+#include <cstdint>
 
 #include <boost/config/warning_disable.hpp>
 #include <boost/fusion/include/adapt_struct.hpp>
 #include <boost/spirit/include/phoenix_object.hpp>
 #include <boost/spirit/include/phoenix_operator.hpp>
 #include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/qi_bool.hpp>
+#include <boost/spirit/include/qi_int.hpp>
 
 #include "xpathquerypart.h"
 
@@ -37,7 +40,7 @@
 BOOST_FUSION_ADAPT_STRUCT(
     xpathselect::XPathQueryParam,
     (std::string, param_name)
-    (std::string, param_value)
+    (xpathselect::XPathQueryParam::ParamValueType, param_value)
     );
 
 namespace xpathselect
@@ -47,6 +50,33 @@
 namespace qi = boost::spirit::qi;
 namespace phoenix = boost::phoenix;
 
+    // python_bool_policy determines what can be considered truthy. We follow python
+    // repr format.
+    struct python_bool_policy : qi::bool_policies<>
+    {
+        template <typename Iterator, typename Attribute>
+        static bool parse_true(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            if (qi::detail::string_parse("True", first, last, qi::unused))
+            {
+                boost::spirit::traits::assign_to(true, attr);    // result is true
+                return true;    // parsing succeeded
+            }
+            return false;   // parsing failed
+        }
+
+        template <typename Iterator, typename Attribute>
+        static bool parse_false(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            if (qi::detail::string_parse("False", first, last, qi::unused))
+            {
+                boost::spirit::traits::assign_to(false, attr);    // result is false
+                return true;
+            }
+            return false;
+        }
+    };
+
     // This is the main XPath grammar. It looks horrible, until you emerse yourself in it for a few
     // days, then the beauty of boost::spirit creeps into your brain. To help future programmers,
     // I've heavily commented this.
@@ -61,6 +91,46 @@
         {
             using namespace qi::labels;
 
+            // character escape codes. The input on the left will produce the output on
+            // the right:
+            unesc_char.add("\\a", '\a')
+                        ("\\b", '\b')
+                        ("\\f", '\f')
+                        ("\\n", '\n')
+                        ("\\r", '\r')
+                        ("\\t", '\t')
+                        ("\\v", '\v')
+                        ("\\\\", '\\')
+                        ("\\\'", '\'')
+                        ("\\\"", '\"');
+
+            unesc_str = '"' >> *(
+                                    unesc_char |
+                                    qi::alnum |
+                                    qi::space |
+                                    "\\x" >> qi::hex
+                                ) >>  '"';
+
+            unesc_str = '"'
+                    >> *(unesc_char | "\\x" >> qi::hex | (qi::print - '"'))
+                    >>  '"'
+                    ;
+
+            int_type = qi::int_parser<int32_t>();
+
+            // Parameter grammar:
+            // parameter name can contain some basic text (no spaces or '.')
+            param_name = +qi::char_("a-zA-Z0-9_\\-");
+
+            // parameter values can be several different types.
+            // Alternatives are tried left to right, and the first match found is the one used.
+            param_value = unesc_str | int_type |  bool_type;
+            // parameter specification is simple: name=value
+            param %= param_name >> '=' >> param_value;
+            // a parameter list is a list of parameters separated by ',''s surrounded in '[...]'
+            param_list = '[' >> param % ',' >> ']';
+
+
             // spec_node_name is a node name that has been explicitly specified.
             // it must start and end with a non-space character, but you can have
             // spaces in the middle.
@@ -68,14 +138,6 @@
             // a wildcard node name is simply a '*'
             wildcard_node_name = qi::char_("*");
 
-            // parameter name can contain some basic text (no spaces or '.')
-            param_name = +qi::char_("a-zA-Z0-9_\\-");
-            // parameter values can have more stuff in them.
-            param_value = +qi::char_("a-z.A-Z0-9_\\-") >> *(+qi::char_(" ") >> +qi::char_("a-z.A-Z0-9_\\-"));
-            // parameter specification is simple: name=value
-            param %= param_name >> '=' >> param_value;
-            // a parameter list is a list of parameters separated by ',''s surrounded in '[...]'
-            param_list = '[' >> param % ',' >> ']';
 
             // a spec_node consists of a specified node name, followed by an *optional* parameter list.
             spec_node %= spec_node_name >> -(param_list);
@@ -83,15 +145,18 @@
             wildcard_node %= wildcard_node_name >> !param_list;
             // wildcard nodes can also have parameters:
             wildcard_node_with_params %= wildcard_node_name >> param_list;
+            // A parent node is '..' as long as it's followed by a normal separator or end of input:
+            parent_node = qi::lit("..")[qi::_val = XPathQueryPart("..")];
 
             // node is simply any kind of code defined thus far:
-            node = spec_node | wildcard_node_with_params | wildcard_node;
+            node = spec_node | wildcard_node_with_params | wildcard_node | parent_node;
 
             // a search node is '//' as long as it's followed by a spec node or a wildcard node with parameters.
             // we don't allow '//*' since it would match everything in the tree, and cause HUGE amounts of
             // data to be transmitted.
             search_node = "//" >> &(spec_node | wildcard_node_with_params)[qi::_val = XPathQueryPart()];
 
+
             // a normal separator is a '/' as long as it's followed by something other than another '/'
             normal_sep = '/' >> !qi::lit('/');
             separator = normal_sep | search_node;  // nodes can be separated by normal_sep or search_node.
@@ -147,14 +212,29 @@
 #endif
         }
         // declare all the rules. The second template parameter is the type they produce.
+        // basic type rules:
+
+        // parse python Boolean represetnations 'True' or 'False':
+        qi::bool_parser<bool, python_bool_policy> bool_type;
+
+        // parse an escaped byte string.
+        qi::rule<Iterator, std::string()> unesc_str;
+        // symbol table for chracter scape codes.
+        qi::symbols<char const, char const> unesc_char;
+
+        // parse integers, first signed then unsigned:
+        qi::rule<Iterator, int32_t()> int_type;
+
+        // more complicated language rules:
         qi::rule<Iterator, std::string()> spec_node_name;
         qi::rule<Iterator, std::string()> wildcard_node_name;
         qi::rule<Iterator, XPathQueryPart()> search_node;
+        qi::rule<Iterator, XPathQueryPart()> parent_node;
         qi::rule<Iterator> normal_sep;
         qi::rule<Iterator, xpathselect::QueryList()> separator;
 
         qi::rule<Iterator, std::string()> param_name;
-        qi::rule<Iterator, std::string()> param_value;
+        qi::rule<Iterator, xpathselect::XPathQueryParam::ParamValueType()> param_value;
         qi::rule<Iterator, XPathQueryParam()> param;
         qi::rule<Iterator, xpathselect::ParamList()> param_list;
 

=== modified file 'lib/xpathquerypart.h'
--- lib/xpathquerypart.h	2013-06-05 07:31:01 +0000
+++ lib/xpathquerypart.h	2013-09-16 15:53:33 +0000
@@ -24,6 +24,8 @@
 #include <iostream>
 
 #include <boost/optional/optional.hpp>
+#include <boost/variant/variant.hpp>
+#include <boost/variant/get.hpp>
 
 #include "node.h"
 
@@ -32,8 +34,11 @@
     // stores a parameter name, value pair.
     struct XPathQueryParam
     {
+        typedef boost::variant<std::string,
+                                bool,
+                                int> ParamValueType;
         std::string param_name;
-        std::string param_value;
+        ParamValueType param_value;
     };
 
     typedef std::vector<XPathQueryParam> ParamList;
@@ -47,7 +52,7 @@
         : node_name_(node_name)
         {}
 
-        enum class QueryPartType {Normal, Search};
+        enum class QueryPartType {Normal, Search, Parent};
 
         bool Matches(Node::Ptr const& node) const
         {
@@ -56,15 +61,39 @@
             {
                 for (auto param : parameter)
                 {
-                    matches &= node->MatchProperty(param.param_name, param.param_value);
-
+                    switch(param.param_value.which())
+                    {
+                        case 0:
+                        {
+                            matches &= node->MatchStringProperty(param.param_name, boost::get<std::string>(param.param_value));
+                        }
+                        break;
+                        case 1:
+                        {
+                            matches &= node->MatchBooleanProperty(param.param_name, boost::get<bool>(param.param_value));
+                        }
+                        break;
+                        case 2:
+                        {
+                            matches &= node->MatchIntegerProperty(param.param_name, boost::get<int>(param.param_value));
+                        }
+                        break;
+                    }
                 }
             }
 
             return matches;
         }
 
-        QueryPartType Type() const { return (node_name_ == "") ? QueryPartType::Search :  QueryPartType::Normal; }
+        QueryPartType Type() const
+        {
+            if (node_name_ == "")
+                return QueryPartType::Search;
+            else if (node_name_ == "..")
+                return QueryPartType::Parent;
+            else
+                return QueryPartType::Normal;
+        }
 
         void Dump() const
         {

=== modified file 'lib/xpathselect.cpp'
--- lib/xpathselect.cpp	2013-04-24 08:57:16 +0000
+++ lib/xpathselect.cpp	2013-09-16 15:53:33 +0000
@@ -82,7 +82,7 @@
         }
     } // end of anonymous namespace
 
-    NodeList SelectNodes(Node::Ptr const& root, std::string query)
+    NodeVector SelectNodes(Node::Ptr const& root, std::string query)
     {
         // allow users to be lazy when specifying tree root:
         if (query == "" || query == "/" || query == "//")
@@ -92,7 +92,7 @@
 
         QueryList query_parts = GetQueryPartsFromQuery(query);
         if (query_parts.empty())
-            return NodeList();
+            return NodeVector();
         auto query_part = query_parts.cbegin();
         NodeList start_nodes { root };
         while (query_part != query_parts.cend())
@@ -105,12 +105,24 @@
                 // do some sanity checking...
                 if (query_part->Type() == XPathQueryPart::QueryPartType::Search)
                     // invalid query - cannot specify multiple search sequences in a row.
-                    return NodeList();
+                    return NodeVector();
                 // then find all the nodes that match the new query part, and store them as
                 // the new start nodes. We pass in 'start_nodes' rather than 'root' since
                 // there's a chance we'll be doing more than one search in different parts of the tree.
                 start_nodes = SearchTreeForNode(start_nodes, *query_part);
             }
+            else if (query_part->Type() == XPathQueryPart::QueryPartType::Parent)
+            {
+                // This part of the query selects the parent node. If the current node has no
+                // parent (i.e.- we're already at the root of the tree) then this is a no-op:
+                NodeList new_start_nodes;
+                for (auto n: start_nodes)
+                {
+                    auto parent = n->GetParent();
+                    new_start_nodes.push_back(parent ? parent : n);
+                }
+                start_nodes = new_start_nodes;
+            }
             else
             {
                 // this isn't a search token. Look at each node in the start_nodes list,
@@ -128,8 +140,11 @@
                     );
             }
             // then replace each node still in the list with all it's children.
-            // ... but only if we're not on the last query part:
-            if (query_part + 1 != query_parts.cend())
+            // ... but only if we're not on the last query part, and only if the
+            // next query part is not a parent node...
+            auto next_query_part = query_part + 1;
+            if (next_query_part != query_parts.cend()
+                && next_query_part->Type() != XPathQueryPart::QueryPartType::Parent)
             {
                 NodeList new_start_nodes;
                 for (auto node: start_nodes)
@@ -147,6 +162,16 @@
             }
             ++query_part;
         }
-        return start_nodes;
+        // remove duplicate nodes by sorting & unique'ing:
+        // we could probably do this better, but since start_nodes is
+        // typically very small at this stage, I'm not sure it's worth it:
+        start_nodes.sort([](Node::Ptr a, Node::Ptr b) -> bool {
+            return a->GetId() < b->GetId();
+        });
+        start_nodes.unique([](Node::Ptr a, Node::Ptr b) -> bool {
+            return a->GetId() == b->GetId();
+        });
+
+        return NodeVector(start_nodes.begin(), start_nodes.end());
     }
 }

=== modified file 'lib/xpathselect.h'
--- lib/xpathselect.h	2013-02-01 23:20:24 +0000
+++ lib/xpathselect.h	2013-09-16 15:53:33 +0000
@@ -24,7 +24,7 @@
 {
     /// Search the node tree beginning with 'root' and return nodes that
     /// match 'query'.
-    extern "C" NodeList SelectNodes(Node::Ptr const& root, std::string query);
+    extern "C" NodeVector SelectNodes(Node::Ptr const& root, std::string query);
 }
 
 #endif

=== modified file 'test/dummynode.h'
--- test/dummynode.h	2013-04-18 03:29:31 +0000
+++ test/dummynode.h	2013-09-16 15:53:33 +0000
@@ -23,12 +23,17 @@
 #include <map>
 
 // simple implementation of the node interface for testing purposes.
-class DummyNode: public xpathselect::Node
+class DummyNode: public xpathselect::Node, public std::enable_shared_from_this<DummyNode>
 {
 public:
+    typedef std::shared_ptr<DummyNode> Ptr;
+
     DummyNode(std::string name="DummyNode")
     : name_(name)
-    {}
+    {
+        static int32_t id = 1;
+        id_ = id++;
+    }
 
     std::string GetName() const override
     {
@@ -40,38 +45,79 @@
         return std::string();
     }
 
+    int32_t GetId() const override
+    {
+        return id_;
+    }
+
     void SetName(std::string const& name)
     {
         name_ = name;
     }
 
-    bool MatchProperty(const std::string& name, const std::string& value) const override
-    {
-        auto it = properties_.find(name);
-        if (it == properties_.end() || it->second != value)
-            return false;
-        return true;
-    }
-
-    xpathselect::NodeList Children() const override
+    bool MatchStringProperty(const std::string& name, const std::string& value) const override
+    {
+        auto it = string_properties_.find(name);
+        if (it == string_properties_.end() || it->second != value)
+            return false;
+        return true;
+    }
+
+    bool MatchBooleanProperty(const std::string& name, bool value) const override
+    {
+        auto it = bool_properties_.find(name);
+        if (it == bool_properties_.end() || it->second != value)
+            return false;
+        return true;
+    }
+
+    bool MatchIntegerProperty(const std::string& name, int value) const override
+    {
+        auto it = int_properties_.find(name);
+        if (it == int_properties_.end() || it->second != value)
+            return false;
+        return true;
+    }
+
+    xpathselect::NodeVector Children() const override
     {
         return children_;
     }
 
-    void AddChild(Node::Ptr const& child)
-    {
+    virtual Node::Ptr GetParent() const override
+    {
+        return parent_;
+    }
+
+    void AddChild(Ptr const& child)
+    {
+        child->parent_ = shared_from_this();
         children_.push_back(child);
     }
 
     void AddProperty(std::string const& name, std::string const& value)
     {
-        properties_[name] = value;
+        string_properties_[name] = value;
+    }
+
+    void AddProperty(std::string const& name, bool value)
+    {
+        bool_properties_[name] = value;
+    }
+
+    void AddProperty(std::string const& name, int value)
+    {
+        int_properties_[name] = value;
     }
 
 private:
+    int32_t id_;
     std::string name_;
-    xpathselect::NodeList children_;
-    std::map<std::string, std::string> properties_;
+    xpathselect::Node::Ptr parent_;
+    xpathselect::NodeVector children_;
+    std::map<std::string, std::string> string_properties_;
+    std::map<std::string, int> int_properties_;
+    std::map<std::string, bool> bool_properties_;
 };
 
 

=== modified file 'test/test_parser.cpp'
--- test/test_parser.cpp	2013-04-24 09:38:10 +0000
+++ test/test_parser.cpp	2013-09-16 15:53:33 +0000
@@ -24,9 +24,13 @@
 #include <boost/spirit/include/phoenix_core.hpp>
 #include <boost/spirit/include/qi_char_class.hpp>
 #include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/variant/variant.hpp>
+
 #include <iostream>
 #include <string>
 #include <cstdlib>
+#include <typeinfo>
+#include <limits>
 
 namespace qi = boost::spirit::qi;
 namespace ascii = boost::spirit::ascii;
@@ -69,6 +73,355 @@
     }
 }
 
+// a boost static visitor that checks value equality and type equality.
+template <typename T>
+class variant_equality_assertion : public boost::static_visitor<>
+{
+public:
+    variant_equality_assertion( T const& expected)
+    : expected_(expected)
+    {}
+
+    void operator()( T & operand ) const
+    {
+        ASSERT_EQ(expected_, operand);
+    }
+
+    template <typename U> void operator()( U & operand ) const
+    {
+        FAIL() << "Variant contained incorrect type! Expected: '"
+        << expected_
+        << "' Actual: '"
+        << operand
+        << "' Actual type is: "
+        << typeid(U).name();
+    }
+private:
+    T expected_;
+};
+
+//////////////////////////////////////
+// Tests for basic type support:
+//////////////////////////////////////
+
+
+// Test python representations for boolean values:
+TEST(TestXPathParser, test_basic_type_boolean)
+{
+    bool result = false;
+    parser::xpath_grammar<std::string::iterator> g;
+
+    ASSERT_TRUE(test_parser_attr("True", g.bool_type, result));
+    ASSERT_TRUE(result);
+
+    ASSERT_TRUE(test_parser_attr("False", g.bool_type, result));
+    ASSERT_FALSE(result);
+
+    ASSERT_FALSE(test_parser_attr("true", g.bool_type, result));
+    ASSERT_FALSE(test_parser_attr("false", g.bool_type, result));
+    ASSERT_FALSE(test_parser_attr("1", g.bool_type, result));
+    ASSERT_FALSE(test_parser_attr("0", g.bool_type, result));
+}
+
+
+// test character escape codes:
+class TestXPathParserCharacterEscapeCodes : public ::testing::TestWithParam<std::pair<std::string, char> >
+{
+};
+
+
+TEST_P(TestXPathParserCharacterEscapeCodes, test_character_escape_codes)
+{
+    auto p = GetParam();
+
+    std::string input = p.first;
+    char expected_result = p.second;
+
+    char actual_result = 0;
+    parser::xpath_grammar<std::string::iterator> g;
+
+    ASSERT_TRUE(test_parser_attr(input, g.unesc_char, actual_result));
+    ASSERT_EQ(expected_result, actual_result);
+}
+
+INSTANTIATE_TEST_CASE_P(BasicCharacterCodes,
+                        TestXPathParserCharacterEscapeCodes,
+                        ::testing::Values(
+                            std::pair<std::string, char>("\\a", '\a'),
+                            std::pair<std::string, char>("\\b", '\b'),
+                            std::pair<std::string, char>("\\f", '\f'),
+                            std::pair<std::string, char>("\\n", '\n'),
+                            std::pair<std::string, char>("\\r", '\r'),
+                            std::pair<std::string, char>("\\t", '\t'),
+                            std::pair<std::string, char>("\\v", '\v'),
+                            std::pair<std::string, char>("\\\\", '\\'),
+                            std::pair<std::string, char>("\\\'", '\''),
+                            std::pair<std::string, char>("\\\"", '\"')
+                        ));
+
+
+class QuotedStringTests : public ::testing::TestWithParam<std::tuple<const char*, const char*, bool> >
+{
+};
+
+TEST_P(QuotedStringTests, quoted_string_parameter_test)
+{
+    std::string input = std::get<0>(GetParam());
+    std::string expected_output = std::get<1>(GetParam());
+    bool expected_pass = std::get<2>(GetParam());
+
+    std::string actual_result;
+    parser::xpath_grammar<std::string::iterator> g;
+
+    ASSERT_EQ(expected_pass, test_parser_attr(input, g.unesc_str, actual_result));
+    if (expected_pass)
+        ASSERT_EQ(expected_output, actual_result);
+}
+
+
+INSTANTIATE_TEST_CASE_P(BasicStrings,
+                        QuotedStringTests,
+                        ::testing::Values(
+                            std::make_tuple("\"Hello\"", "Hello", true),
+                            std::make_tuple("\"Hello World\"", "Hello World", true),
+                            std::make_tuple("\"a b  c   d\"", "a b  c   d", true),
+                            std::make_tuple("\"\\x41\"", "A", true),
+                            std::make_tuple("\"\\x08\"", "\b", true)
+                            ));
+
+INSTANTIATE_TEST_CASE_P(PunctuationStrings,
+                        QuotedStringTests,
+                        ::testing::Values(
+                            std::make_tuple("\".\"", ".", true),
+                            std::make_tuple("\",\"", ",", true),
+                            std::make_tuple("\"<\"", "<", true),
+                            std::make_tuple("\">\"", ">", true),
+                            std::make_tuple("\"/\"", "/", true),
+                            std::make_tuple("\"?\"", "?", true),
+                            std::make_tuple("\":\"", ":", true),
+                            std::make_tuple("\";\"", ";", true),
+                            std::make_tuple("\"'\"", "'", true), // '"' tested below
+                            std::make_tuple("\"[\"", "[", true),
+                            std::make_tuple("\"]\"", "]", true),
+                            std::make_tuple("\"{\"", "{", true),
+                            std::make_tuple("\"}\"", "}", true),
+                            std::make_tuple("\"\\\\\"", "\\", true),
+                            std::make_tuple("\"|\"", "|", true),
+                            std::make_tuple("\"~\"", "~", true),
+                            std::make_tuple("\"`\"", "`", true),
+                            std::make_tuple("\"!\"", "!", true),
+                            std::make_tuple("\"@\"", "@", true),
+                            std::make_tuple("\"#\"", "#", true),
+                            std::make_tuple("\"$\"", "$", true),
+                            std::make_tuple("\"%\"", "%", true),
+                            std::make_tuple("\"^\"", "^", true),
+                            std::make_tuple("\"&\"", "&", true),
+                            std::make_tuple("\"*\"", "*", true),
+                            std::make_tuple("\"(\"", "(", true),
+                            std::make_tuple("\")\"", ")", true),
+                            std::make_tuple("\"-\"", "-", true),
+                            std::make_tuple("\"_\"", "_", true),
+                            std::make_tuple("\"+\"", "+", true),
+                            std::make_tuple("\"=\"", "=", true)
+                            ));
+
+INSTANTIATE_TEST_CASE_P(QuoteStrings,
+                        QuotedStringTests,
+                        ::testing::Values(
+                            std::make_tuple("\"\\\"\"", "\"", true),
+                            std::make_tuple("\"\\\'\"", "\'", true)
+                            ));
+
+INSTANTIATE_TEST_CASE_P(NumberStrings,
+                        QuotedStringTests,
+                        ::testing::Values(
+                            std::make_tuple("\"0\"", "0", true),
+                            std::make_tuple("\"1\"", "1", true),
+                            std::make_tuple("\"2\"", "2", true),
+                            std::make_tuple("\"3\"", "3", true),
+                            std::make_tuple("\"4\"", "4", true),
+                            std::make_tuple("\"5\"", "5", true),
+                            std::make_tuple("\"6\"", "6", true),
+                            std::make_tuple("\"7\"", "7", true),
+                            std::make_tuple("\"8\"", "8", true),
+                            std::make_tuple("\"9\"", "9", true)
+                            ));
+
+
+TEST(TestIntegerTypes, test_signed_integers)
+{
+    int result = 0;
+    parser::xpath_grammar<std::string::iterator> g;
+
+    ASSERT_TRUE(test_parser_attr("123", g.int_type, result));
+    ASSERT_EQ(123, result);
+
+    ASSERT_TRUE(test_parser_attr("+456", g.int_type, result));
+    ASSERT_EQ(456, result);
+
+    ASSERT_TRUE(test_parser_attr("-123", g.int_type, result));
+    ASSERT_EQ(-123, result);
+}
+
+
+// This test fails due to a bug in boost::spirit: https://svn.boost.org/trac/boost/ticket/9007
+// TEST(TestIntegerTypes, test_integer_overflow)
+// {
+//     int result;
+
+//     // store range of int in a long, since we'll be extending them
+//     long min_int = std::numeric_limits<int>::min();
+//     long max_int = std::numeric_limits<int>::max();
+
+//     qi::int_parser<int> r;
+
+//     ASSERT_TRUE(test_parser_attr(std::to_string(min_int), r, result));
+//     ASSERT_EQ(min_int, result);
+
+//     ASSERT_TRUE(test_parser_attr(std::to_string(max_int), r, result));
+//     ASSERT_EQ(max_int, result);
+
+//     min_int -= 1;
+//     max_int += 1;
+
+//     // these last two assertions are failing. I expect the parsing to fail, but it's passing
+//     // for some reason.
+//     ASSERT_FALSE(test_parser_attr(std::to_string(min_int), r, result)) << min_int;
+//     ASSERT_FALSE(test_parser_attr(std::to_string(max_int), r, result)) << max_int;
+// }
+
+
+////////////////////////////////////
+// more complicated grammar tests
+////////////////////////////////////
+
+/// Tests for parameter names:
+class TestXPathParserParamNames : public ::testing::TestWithParam<std::pair<std::string, bool> >
+{
+};
+
+TEST_P(TestXPathParserParamNames, test_param_name)
+{
+    auto p = GetParam();
+
+    std::string input = p.first;
+    bool expect_pass = p.second;
+
+    parser::xpath_grammar<std::string::iterator> g;
+
+    std::string result;
+    ASSERT_EQ( expect_pass,  test_parser_attr(input, g.param_name, result) );
+    if (expect_pass)
+        ASSERT_EQ(input, result);
+}
+
+INSTANTIATE_TEST_CASE_P(BasicNodeNames,
+                        TestXPathParserParamNames,
+                        ::testing::Values(
+                            std::pair<std::string, bool>("a b", false),
+                            std::pair<std::string, bool>("a*", false),
+                            std::pair<std::string, bool>("HelloWorld", true),
+                            std::pair<std::string, bool>("H", true),
+                            std::pair<std::string, bool>("h", true),
+                            std::pair<std::string, bool>("1", true),
+                            std::pair<std::string, bool>("node-name", true),
+                            std::pair<std::string, bool>("node_name", true),
+                            std::pair<std::string, bool>("node\\name", true),
+                            std::pair<std::string, bool>("node.name", false),
+                            std::pair<std::string, bool>("node name", false),
+                            std::pair<std::string, bool>("..", false)
+                         ));
+
+/// Tests for parameter values. This test is much larger than it should be, since it seems to be
+// impossible to parameterise tests for both type and value. The solution I use here is to have
+// the actual test in a base class template method, and have several derive classes use different
+// value parameters. Ugly, but probably the best we can do with google test.
+
+class TestParamValues : public ::testing::Test
+{
+public:
+    template <typename PairType>
+    void test_param_value(PairType const& input_pair) const
+    {
+        RecordProperty("FirstType", typeid(typename PairType::first_type).name());
+        RecordProperty("SecondType", typeid(typename PairType::second_type).name());
+        std::string input = input_pair.first;
+        typename PairType::second_type expected_result = input_pair.second;
+
+        parser::xpath_grammar<std::string::iterator> g;
+
+        xpathselect::XPathQueryParam::ParamValueType result;
+        ASSERT_TRUE( test_parser_attr(input, g.param_value, result) );
+        boost::apply_visitor(
+            variant_equality_assertion<typename PairType::second_type>(expected_result),
+            result
+            );
+    }
+};
+
+// test string parameter values:
+class TestStringParamValues
+ : public ::testing::WithParamInterface<std::pair<std::string, std::string> >
+ , public TestParamValues
+{
+};
+
+TEST_P(TestStringParamValues, test_param_value_str)
+{
+    auto p = GetParam();
+    test_param_value(p);
+}
+
+INSTANTIATE_TEST_CASE_P(StringParams,
+                        TestStringParamValues,
+                        ::testing::Values(
+                            std::pair<std::string, std::string>("\"a b\"", "a b" ),
+                            std::pair<std::string, std::string>("\"a.b,c/\\d^\"", "a.b,c/\\d^" )
+                         ));
+
+// test boolean parameter values:
+class TestBoolParamValues
+ : public ::testing::WithParamInterface<std::pair<std::string, bool> >
+ , public TestParamValues
+{
+};
+
+TEST_P(TestBoolParamValues, test_param_value_bool)
+{
+    auto p = GetParam();
+    test_param_value(p);
+}
+
+INSTANTIATE_TEST_CASE_P(StringParams,
+                        TestBoolParamValues,
+                        ::testing::Values(
+                            std::pair<std::string, bool>("True", true ),
+                            std::pair<std::string, bool>("False", false )
+                         ));
+
+// test integer parameter values:
+class TestIntParamValues
+ : public ::testing::WithParamInterface<std::pair<std::string, int> >
+ , public TestParamValues
+{
+};
+
+TEST_P(TestIntParamValues, test_param_value_bool)
+{
+    auto p = GetParam();
+    test_param_value(p);
+}
+
+INSTANTIATE_TEST_CASE_P(IntegerParams,
+                        TestIntParamValues,
+                        ::testing::Values(
+                            std::pair<std::string, int>("123", 123 ),
+                            std::pair<std::string, int>("0", 0 ),
+                            std::pair<std::string, int>("-123", -123 )
+                         ));
+
+
+/// Tests for the node names:
 class TestXPathParserNodeNames : public ::testing::TestWithParam<std::pair<std::string, bool> >
 {
 };
@@ -108,87 +461,6 @@
                             std::pair<std::string, bool>("node\\name", true)
                          ));
 
-class TestXPathParserParamNames : public ::testing::TestWithParam<std::pair<std::string, bool> >
-{
-};
-
-TEST_P(TestXPathParserParamNames, test_param_name)
-{
-    auto p = GetParam();
-
-    std::string input = p.first;
-    bool expect_pass = p.second;
-
-    parser::xpath_grammar<std::string::iterator> g;
-
-    std::string result;
-    ASSERT_EQ( expect_pass,  test_parser_attr(input, g.param_name, result) );
-    if (expect_pass)
-        ASSERT_EQ(input, result);
-}
-
-INSTANTIATE_TEST_CASE_P(BasicNodeNames,
-                        TestXPathParserParamNames,
-                        ::testing::Values(
-                            std::pair<std::string, bool>("a b", false),
-                            std::pair<std::string, bool>("a*", false),
-                            std::pair<std::string, bool>("HelloWorld", true),
-                            std::pair<std::string, bool>("H", true),
-                            std::pair<std::string, bool>("h", true),
-                            std::pair<std::string, bool>("1", true),
-                            std::pair<std::string, bool>("node-name", true),
-                            std::pair<std::string, bool>("node_name", true),
-                            std::pair<std::string, bool>("node\\name", true),
-                            std::pair<std::string, bool>("node.name", false),
-                            std::pair<std::string, bool>("node name", false)
-                         ));
-
-class TestXPathParserParamValues : public ::testing::TestWithParam<std::pair<std::string, bool> >
-{
-};
-
-TEST_P(TestXPathParserParamValues, test_param_value)
-{
-    auto p = GetParam();
-
-    std::string input = p.first;
-    bool expect_pass = p.second;
-
-    parser::xpath_grammar<std::string::iterator> g;
-
-    std::string result;
-    ASSERT_EQ( expect_pass,  test_parser_attr(input, g.param_value, result) );
-    if (expect_pass)
-        ASSERT_EQ(input, result);
-}
-
-INSTANTIATE_TEST_CASE_P(BasicNodeNames,
-                        TestXPathParserParamValues,
-                        ::testing::Values(
-                            std::pair<std::string, bool>("a b", true),
-                            std::pair<std::string, bool>("a*", false),
-                            std::pair<std::string, bool>("HelloWorld", true),
-                            std::pair<std::string, bool>("H", true),
-                            std::pair<std::string, bool>("h", true),
-                            std::pair<std::string, bool>("1", true),
-                            std::pair<std::string, bool>("node-name", true),
-                            std::pair<std::string, bool>("node_name", true),
-                            std::pair<std::string, bool>("node\\name", true),
-                            std::pair<std::string, bool>("node name", true),
-                            std::pair<std::string, bool>("node.name", true)
-                         ));
-
-
-TEST(TestXPathParser, test_wildcard_node_name_accepts_wildcards)
-{
-    std::string input("*");
-
-    parser::xpath_grammar<std::string::iterator> g;
-
-    std::string result;
-    ASSERT_EQ( true,  test_parser_attr(input, g.wildcard_node_name, result) );
-    ASSERT_EQ(input, result);
-}
 
 class TestXPathParserWildcardNodeName : public ::testing::TestWithParam<std::pair<std::string, bool> >
 {
@@ -224,16 +496,49 @@
                          ));
 
 
-TEST(TestXPathParser, test_param_parser_works)
-{
-    std::string input("name=value");
-
-    parser::xpath_grammar<std::string::iterator> g;
-
-    xpathselect::XPathQueryParam result;
-    ASSERT_EQ( true,  test_parser_attr(input, g.param, result) );
-    ASSERT_EQ("name", result.param_name);
-    ASSERT_EQ("value", result.param_value);
+TEST(TestXPathParser, test_param_parser_string_value_works)
+{
+    std::string input("name=\"value\"");
+
+    parser::xpath_grammar<std::string::iterator> g;
+
+    xpathselect::XPathQueryParam result;
+    ASSERT_EQ( true,  test_parser_attr(input, g.param, result) );
+    ASSERT_EQ("name", result.param_name);
+    boost::apply_visitor(
+        variant_equality_assertion<std::string>("value"),
+        result.param_value
+        );
+}
+
+TEST(TestXPathParser, test_param_parser_bool_value_works)
+{
+    std::string input("name=True");
+
+    parser::xpath_grammar<std::string::iterator> g;
+
+    xpathselect::XPathQueryParam result;
+    ASSERT_EQ( true,  test_parser_attr(input, g.param, result) );
+    ASSERT_EQ("name", result.param_name);
+    boost::apply_visitor(
+        variant_equality_assertion<bool>(true),
+        result.param_value
+        );
+}
+
+TEST(TestXPathParser, test_param_parser_string_int_works)
+{
+    std::string input("name=123456");
+
+    parser::xpath_grammar<std::string::iterator> g;
+
+    xpathselect::XPathQueryParam result;
+    ASSERT_EQ( true,  test_parser_attr(input, g.param, result) );
+    ASSERT_EQ("name", result.param_name);
+    boost::apply_visitor(
+        variant_equality_assertion<int>(123456),
+        result.param_value
+        );
 }
 
 TEST(TestXPathParser, test_param_parser_fails)
@@ -256,12 +561,15 @@
     ASSERT_EQ( true,  test_parser_attr(input, g.param_list, result) );
     ASSERT_EQ(1, result.size());
     ASSERT_EQ("name", result.at(0).param_name);
-    ASSERT_EQ("123", result.at(0).param_value);
+    boost::apply_visitor(
+        variant_equality_assertion<int>(123),
+        result.at(0).param_value
+        );
 }
 
 TEST(TestXPathParser, test_param_list_two_values)
 {
-    std::string input("[name=value,other=foo]");
+    std::string input("[name=\"value\",visible=True]");
 
     parser::xpath_grammar<std::string::iterator> g;
 
@@ -269,9 +577,15 @@
     ASSERT_EQ( true,  test_parser_attr(input, g.param_list, result) );
     ASSERT_EQ(2, result.size());
     ASSERT_EQ("name", result.at(0).param_name);
-    ASSERT_EQ("value", result.at(0).param_value);
-    ASSERT_EQ("other", result.at(1).param_name);
-    ASSERT_EQ("foo", result.at(1).param_value);
+    boost::apply_visitor(
+        variant_equality_assertion<std::string>("value"),
+        result.at(0).param_value
+        );
+    ASSERT_EQ("visible", result.at(1).param_name);
+    boost::apply_visitor(
+        variant_equality_assertion<bool>(true),
+        result.at(1).param_value
+        );
 }
 
 TEST(TestXPathParser, test_spec_node_with_parameter)
@@ -285,7 +599,10 @@
     ASSERT_EQ("node_name", result.node_name_);
     ASSERT_FALSE(result.parameter.empty());
     ASSERT_EQ("param_name", result.parameter.at(0).param_name);
-    ASSERT_EQ("123", result.parameter.at(0).param_value);
+    boost::apply_visitor(
+        variant_equality_assertion<int>(123),
+        result.parameter.at(0).param_value
+        );
 }
 
 TEST(TestXPathParser, test_spec_node_without_parameter)
@@ -333,13 +650,16 @@
     ASSERT_EQ("*", result.node_name_);
     ASSERT_FALSE(result.parameter.empty());
     ASSERT_EQ("param_name", result.parameter.at(0).param_name);
-    ASSERT_EQ("123", result.parameter.at(0).param_value);
+    boost::apply_visitor(
+        variant_equality_assertion<int>(123),
+        result.parameter.at(0).param_value
+        );
 }
 
 
 TEST(TestXPathParser, test_node_can_be_a_wildcard_node_with_params)
 {
-    std::string input("*[name=value]");
+    std::string input("*[name=\"value\"]");
 
     parser::xpath_grammar<std::string::iterator> g;
 
@@ -349,7 +669,10 @@
     ASSERT_EQ( xpathselect::XPathQueryPart::QueryPartType::Normal, result.Type() );
     ASSERT_EQ( 1, result.parameter.size() );
     ASSERT_EQ( "name", result.parameter.at(0).param_name );
-    ASSERT_EQ( "value", result.parameter.at(0).param_value );
+    boost::apply_visitor(
+        variant_equality_assertion<std::string>("value"),
+        result.parameter.at(0).param_value
+        );
 }
 
 TEST(TestXPathParser, test_node_can_be_a_wildcard_node_without_params)
@@ -366,7 +689,7 @@
 
 TEST(TestXPathParser, test_node_can_be_a_spec_node_with_params)
 {
-    std::string input("foo[name=value]");
+    std::string input("foo[name=\"value\"]");
 
     parser::xpath_grammar<std::string::iterator> g;
 
@@ -376,7 +699,10 @@
     ASSERT_EQ( xpathselect::XPathQueryPart::QueryPartType::Normal, result.Type() );
     ASSERT_EQ( 1, result.parameter.size() );
     ASSERT_EQ( "name", result.parameter.at(0).param_name );
-    ASSERT_EQ( "value", result.parameter.at(0).param_value );
+    boost::apply_visitor(
+        variant_equality_assertion<std::string>("value"),
+        result.parameter.at(0).param_value
+        );
 }
 
 TEST(TestXPathParser, test_node_can_be_a_spec_node_without_params)
@@ -391,6 +717,18 @@
     ASSERT_EQ( xpathselect::XPathQueryPart::QueryPartType::Normal, result.Type() );
 }
 
+TEST(TestXPathParser, test_node_can_be_a_parent_node)
+{
+    std::string input("..");
+
+    parser::xpath_grammar<std::string::iterator> g;
+
+    xpathselect::XPathQueryPart result;
+    ASSERT_EQ( true,  test_parser_attr(input, g.node, result) );
+    ASSERT_EQ( "..", result.node_name_ );
+    ASSERT_EQ( xpathselect::XPathQueryPart::QueryPartType::Parent, result.Type() );
+}
+
 TEST(TestXPathParser, test_search_node_followed_by_normal_node)
 {
     // the search_node grammar fails if it's at the end of the line, so we need
@@ -409,7 +747,7 @@
 {
     // the search_node grammar fails if it's at the end of the line, so we need
     // to give it some more data, even though we're not actually matching it.
-    std::string input("//*[foo=bar]");
+    std::string input("//*[foo=\"bar\"]");
     parser::xpath_grammar<std::string::iterator> g;
     xpathselect::XPathQueryPart result;
 
@@ -429,6 +767,17 @@
     ASSERT_FALSE( test_parser_attr(input, g.search_node, result) );
 }
 
+TEST(TestXPathParser, test_parent_node)
+{
+    std::string input("..");
+
+    parser::xpath_grammar<std::string::iterator> g;
+
+    xpathselect::XPathQueryPart result;
+    ASSERT_TRUE( test_parser_attr(input, g.parent_node, result) );
+    ASSERT_TRUE( result.Type() == xpathselect::XPathQueryPart::QueryPartType::Parent );
+}
+
 TEST(TestXPathParser, test_normal_sep_works)
 {
     std::string input("/");
@@ -503,7 +852,7 @@
 
 TEST(TestXPathParser, test_mix_search_and_long_normal)
 {
-    std::string input("/node1//node2[name=val]/node3");
+    std::string input("/node1//node2[name=\"val\"]/node3");
 
     parser::xpath_grammar<std::string::iterator> g;
 
@@ -521,17 +870,55 @@
     ASSERT_EQ("node2", result.at(2).node_name_);
     ASSERT_EQ(1, result.at(2).parameter.size());
     ASSERT_EQ("name", result.at(2).parameter.at(0).param_name);
-    ASSERT_EQ("val", result.at(2).parameter.at(0).param_value);
-
+    boost::apply_visitor(
+        variant_equality_assertion<std::string>("val"),
+        result.at(2).parameter.at(0).param_value
+        );
     ASSERT_EQ("node3", result.at(3).node_name_);
     ASSERT_TRUE(result.at(3).parameter.empty());
 }
 
+TEST(TestXPathParser, test_mix_normal_and_parent)
+{
+    std::string input("/node1/..");
+
+    parser::xpath_grammar<std::string::iterator> g;
+
+    xpathselect::QueryList result;
+    ASSERT_TRUE(test_parser_attr(input, g.node_sequence, result));
+
+    ASSERT_EQ(2, result.size());
+
+    ASSERT_EQ("node1", result.at(0).node_name_);
+    ASSERT_TRUE(result.at(0).parameter.empty());
+
+    ASSERT_TRUE(result.at(1).Type() == xpathselect::XPathQueryPart::QueryPartType::Parent );
+    ASSERT_TRUE(result.at(1).parameter.empty());
+}
+
+TEST(TestXPathParser, test_mix_normal_and_parent_and_wildcard)
+{
+    std::string input("/node1/../*");
+
+    parser::xpath_grammar<std::string::iterator> g;
+
+    xpathselect::QueryList result;
+    ASSERT_TRUE(test_parser_attr(input, g.node_sequence, result));
+
+    ASSERT_EQ(3, result.size());
+
+    ASSERT_EQ("node1", result.at(0).node_name_);
+    ASSERT_TRUE(result.at(0).parameter.empty());
+
+    ASSERT_TRUE(result.at(1).Type() == xpathselect::XPathQueryPart::QueryPartType::Parent );
+    ASSERT_TRUE(result.at(1).parameter.empty());
+
+    ASSERT_TRUE(result.at(2).node_name_ == "*" );
+    ASSERT_TRUE(result.at(2).parameter.empty());
+}
 
 class TestXPathParserQueryStrings : public ::testing::TestWithParam<std::pair<std::string, bool> >
-{
-};
-
+{};
 
 TEST_P(TestXPathParserQueryStrings, test_query_acceptance)
 {
@@ -556,11 +943,11 @@
                             std::pair<std::string, bool>("/root//node1", true),
                             std::pair<std::string, bool>("//root", true),
                             std::pair<std::string, bool>("/root//node1/node2", true),
-                            std::pair<std::string, bool>("/root[p=1]//node1[p=2]/node3", true),
-                            std::pair<std::string, bool>("/root[p=1,n=2,d=e3]", true),
-                            std::pair<std::string, bool>("//root[p=1,n=2,d=e3]", true),
+                            std::pair<std::string, bool>("/root[p=1]//node1[p=\"2\"]/node3", true),
+                            std::pair<std::string, bool>("/root[p=True,n=2,d=\"e3\"]", true),
+                            std::pair<std::string, bool>("//root[p=1,n=2,d=\"e3\"]", true),
                             std::pair<std::string, bool>("/Root//*[p=1]", true),
-                            std::pair<std::string, bool>("/Root//*[p=1,v=sj,c=true]", true),
+                            std::pair<std::string, bool>("/Root//*[p=1,v=\"sj\",c=False]", true),
                             // queries that must not parse correctly:
                             std::pair<std::string, bool>("//", false),
                             std::pair<std::string, bool>("/root//", false),
@@ -570,5 +957,7 @@
                             std::pair<std::string, bool>(" ", false),
                             std::pair<std::string, bool>("//*", false),
                             std::pair<std::string, bool>("/Root///Leaf", false),
-                            std::pair<std::string, bool>("/Root////", false)
+                            std::pair<std::string, bool>("/Root////", false),
+                            std::pair<std::string, bool>("/Root/..*", false),
+                            std::pair<std::string, bool>("/Root/../Child//..", false)
                          ));

=== modified file 'test/test_xpath_simple.cpp'
--- test/test_xpath_simple.cpp	2012-08-10 04:06:05 +0000
+++ test/test_xpath_simple.cpp	2013-09-16 15:53:33 +0000
@@ -26,7 +26,7 @@
 TEST(TestXPath, test_select_empty_tree)
 {
     xpathselect::Node::Ptr tree_root = std::make_shared<DummyNode>();
-    xpathselect::NodeList result = xpathselect::SelectNodes(tree_root, "");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(tree_root, "");
 
     ASSERT_EQ(1, result.size());
 }
@@ -35,7 +35,7 @@
 TEST(TestXPath, test_select_tree_root)
 {
     xpathselect::Node::Ptr tree_root = std::make_shared<DummyNode>("RootNode");
-    xpathselect::NodeList result = xpathselect::SelectNodes(tree_root, "/");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(tree_root, "/");
 
     ASSERT_EQ(result.size(), 1);
     ASSERT_EQ(result.front(), tree_root);
@@ -45,7 +45,7 @@
 TEST(TestXPath, test_select_tree_root_with_name)
 {
     xpathselect::Node::Ptr tree_root = std::make_shared<DummyNode>("RootNode");
-    xpathselect::NodeList result = xpathselect::SelectNodes(tree_root, "/RootNode");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(tree_root, "/RootNode");
 
     ASSERT_EQ(result.size(), 1);
     ASSERT_EQ(result.front(), tree_root);
@@ -55,7 +55,7 @@
 TEST(TestXPath, test_select_tree_root_with_relative_query)
 {
     xpathselect::Node::Ptr tree_root = std::make_shared<DummyNode>("RootNode");
-    xpathselect::NodeList result = xpathselect::SelectNodes(tree_root, "//RootNode");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(tree_root, "//RootNode");
 
     ASSERT_EQ(result.size(), 1);
     ASSERT_EQ(result.front(), tree_root);
@@ -65,7 +65,7 @@
 TEST(TestXPath, test_select_tree_root_with_empty_relative_query)
 {
     xpathselect::Node::Ptr tree_root = std::make_shared<DummyNode>("RootNode");
-    xpathselect::NodeList result = xpathselect::SelectNodes(tree_root, "//");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(tree_root, "//");
 
     ASSERT_EQ(result.size(), 1);
     ASSERT_EQ(result.front(), tree_root);

=== modified file 'test/test_xpath_tree.cpp'
--- test/test_xpath_tree.cpp	2013-04-24 03:48:30 +0000
+++ test/test_xpath_tree.cpp	2013-09-16 15:53:33 +0000
@@ -49,14 +49,14 @@
 
 TEST_F(TestTreeFixture, test_simple)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/");
 
     ASSERT_EQ(1, result.size());
 }
 
 TEST_F(TestTreeFixture, test_simple_absolute)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1");
 
     ASSERT_EQ(1, result.size());
     auto expected = child_l1_;
@@ -66,7 +66,7 @@
 
 TEST_F(TestTreeFixture, test_simple_relative)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "//ChildRight1");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "//ChildRight1");
 
     ASSERT_EQ(1, result.size());
     ASSERT_EQ(child_r1_, result.front());
@@ -74,7 +74,7 @@
 
 TEST_F(TestTreeFixture, test_complex_relative)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "//Root/ChildRight1");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "//Root/ChildRight1");
 
     ASSERT_EQ(1, result.size());
     ASSERT_EQ(child_r1_, result.front());
@@ -82,7 +82,7 @@
 
 TEST_F(TestTreeFixture, test_relative_multiple_return)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "//Leaf");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "//Leaf");
 
     ASSERT_EQ(2, result.size());
 
@@ -94,7 +94,7 @@
 
 TEST_F(TestTreeFixture, test_relative_wildcard)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "//ChildLeft1/*");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "//ChildLeft1/*");
 
     ASSERT_EQ(2, result.size());
 
@@ -106,7 +106,7 @@
 
 TEST_F(TestTreeFixture, test_absolute_wildcard)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1/*");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1/*");
 
     ASSERT_EQ(2, result.size());
 
@@ -119,7 +119,7 @@
 TEST_F(TestTreeFixture, test_simple_absolute_property_match)
 {
     child_l1_->AddProperty("visible", "True");
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1[visible=True]");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1[visible=True]");
 
     ASSERT_EQ(1, result.size());
     ASSERT_EQ(child_l1_, result.front());
@@ -127,8 +127,8 @@
 
 TEST_F(TestTreeFixture, test_simple_relative_property_match)
 {
-    child_l1_->AddProperty("visible", "True");
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "//ChildLeft1[visible=True]");
+    child_l1_->AddProperty("visible", true);
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "//ChildLeft1[visible=True]");
 
     ASSERT_EQ(1, result.size());
     ASSERT_EQ(child_l1_, result.front());
@@ -136,9 +136,9 @@
 
 TEST_F(TestTreeFixture, test_absolute_multiple_property_match)
 {
-    root_->AddProperty("number", "45");
-    child_l1_->AddProperty("visible", "True");
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root[number=45]/ChildLeft1[visible=True]");
+    root_->AddProperty("number", 45);
+    child_l1_->AddProperty("visible", true);
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root[number=45]/ChildLeft1[visible=True]");
 
     ASSERT_EQ(1, result.size());
     ASSERT_EQ(child_l1_, result.front());
@@ -146,7 +146,7 @@
 
 TEST_F(TestTreeFixture, test_mixed_query_simple)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root//Leaf");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root//Leaf");
     ASSERT_EQ(2, result.size());
     for(auto n : result)
     {
@@ -156,8 +156,8 @@
 
 TEST_F(TestTreeFixture, test_mixed_query_property_match)
 {
-    leaf_1_->AddProperty("visible", "True");
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root//Leaf[visible=True]");
+    leaf_1_->AddProperty("visible", true);
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root//Leaf[visible=True]");
 
     ASSERT_EQ(1, result.size());
     ASSERT_EQ(leaf_1_, result.front());
@@ -165,8 +165,8 @@
 
 TEST_F(TestTreeFixture, test_search_node_with_wildcard_and_property)
 {
-    child_l1_->AddProperty("visible", "True");
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root//*[visible=True]");
+    child_l1_->AddProperty("visible", true);
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root//*[visible=True]");
 
     ASSERT_EQ(1, result.size());
     ASSERT_EQ(child_l1_, result.front());
@@ -174,7 +174,7 @@
 
 TEST_F(TestTreeFixture, test_wildcard)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root/*");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root/*");
     ASSERT_EQ(2, result.size());
     for(auto n : result)
     {
@@ -182,14 +182,54 @@
     }
 }
 
+TEST_F(TestTreeFixture, test_parent)
+{
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1/..");
+
+    ASSERT_EQ(1, result.size());
+    ASSERT_EQ(root_, result.front());
+}
+
+TEST_F(TestTreeFixture, test_parent_on_root)
+{
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root/..");
+
+    ASSERT_EQ(1, result.size());
+    ASSERT_EQ(root_, result.front());
+}
+
+TEST_F(TestTreeFixture, test_parent_on_leaf)
+{
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1/Leaf/..");
+
+    ASSERT_EQ(1, result.size());
+    ASSERT_EQ(child_l1_, result.front());
+}
+
+TEST_F(TestTreeFixture, test_double_parent_on_leaf)
+{
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1/Leaf/../..");
+
+    ASSERT_EQ(1, result.size());
+    ASSERT_EQ(root_, result.front());
+}
+
+TEST_F(TestTreeFixture, test_parent_and_child)
+{
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root/ChildLeft1/../ChildLeft1/../ChildLeft1");
+
+    ASSERT_EQ(1, result.size());
+    ASSERT_EQ(child_l1_, result.front());
+}
+
 TEST_F(TestTreeFixture, test_invalid_query_search)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root///Leaf");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root///Leaf");
     ASSERT_EQ(0, result.size());
 }
 
 TEST_F(TestTreeFixture, test_invalid_query_multiple_searches)
 {
-    xpathselect::NodeList result = xpathselect::SelectNodes(root_, "/Root////");
+    xpathselect::NodeVector result = xpathselect::SelectNodes(root_, "/Root////");
     ASSERT_EQ(0, result.size());
 }