← Back to branch summary

~ubuntu-branches/ubuntu/vivid/xpathselect/vivid

« back to all changes in this revision

Viewing changes to test/test_parser.cpp

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release, Thomi Richards, Timo Jyrinki, Christopher Lee, Ubuntu daily release
  • Date: 2013-06-05 09:01:46 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20130605090146-piiba0hwhb71rmu0
Tags: 1.3daily13.06.05.1-0ubuntu1
[ Thomi Richards ]
* Comment change.
* Update parser to allow spaces in object names, spaces and periods in
  param values, and fix several other bugs in the parser. (LP:
  #1150276)

[ Timo Jyrinki ]
* Fix FTBFS by adding a missing include.

[ Christopher Lee ]
* Update parser to allow spaces in object names, spaces and periods in
  param values, and fix several other bugs in the parser. (LP:
  #1150276)

[ Ubuntu daily release ]
* Automatic snapshot from revision 36

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_parser.cpp
52
52
    }
53
53
}
54
54
 
55
 
class TestXPathParser : public ::testing::TestWithParam<std::pair<std::string, bool> >
 
55
template <typename P>
 
56
bool test_parser_attr(std::string input, P const& p)
 
57
{
 
58
    using boost::spirit::qi::parse;
 
59
 
 
60
    std::string::iterator f = input.begin();
 
61
    std::string::iterator l = input.end();
 
62
    if (parse(f, l, p) && (f == l))
 
63
    {
 
64
        return true;
 
65
    }
 
66
    else
 
67
    {
 
68
        return false;
 
69
    }
 
70
}
 
71
 
 
72
class TestXPathParserNodeNames : public ::testing::TestWithParam<std::pair<std::string, bool> >
56
73
{
57
74
};
58
75
 
59
76
 
60
 
TEST_P(TestXPathParser, test_node_name)
 
77
TEST_P(TestXPathParserNodeNames, test_spec_node_name)
61
78
{
62
79
    auto p = GetParam();
63
80
 
67
84
    parser::xpath_grammar<std::string::iterator> g;
68
85
 
69
86
    std::string result;
70
 
    ASSERT_EQ( expect_pass,  test_parser_attr(input, g.node_name, result) );
 
87
    ASSERT_EQ( expect_pass,  test_parser_attr(input, g.spec_node_name, result) );
71
88
    if (expect_pass)
72
89
        ASSERT_EQ(input, result);
73
90
}
74
91
 
75
 
TEST_P(TestXPathParser, test_param_name)
 
92
INSTANTIATE_TEST_CASE_P(BasicNodeNames,
 
93
                        TestXPathParserNodeNames,
 
94
                        ::testing::Values(
 
95
                            std::pair<std::string, bool>("a b", true),
 
96
                            std::pair<std::string, bool>("a ", false),
 
97
                            std::pair<std::string, bool>(" ", false),
 
98
                            std::pair<std::string, bool>(" b", false),
 
99
                            std::pair<std::string, bool>("a    b", true),
 
100
                            std::pair<std::string, bool>("a b b a", true),
 
101
                            std::pair<std::string, bool>("a*", false),
 
102
                            std::pair<std::string, bool>("HelloWorld", true),
 
103
                            std::pair<std::string, bool>("H", true),
 
104
                            std::pair<std::string, bool>("h", true),
 
105
                            std::pair<std::string, bool>("1", true),
 
106
                            std::pair<std::string, bool>("node-name", true),
 
107
                            std::pair<std::string, bool>("node_name", true),
 
108
                            std::pair<std::string, bool>("node\\name", true)
 
109
                         ));
 
110
 
 
111
class TestXPathParserParamNames : public ::testing::TestWithParam<std::pair<std::string, bool> >
 
112
{
 
113
};
 
114
 
 
115
TEST_P(TestXPathParserParamNames, test_param_name)
76
116
{
77
117
    auto p = GetParam();
78
118
 
87
127
        ASSERT_EQ(input, result);
88
128
}
89
129
 
90
 
TEST_P(TestXPathParser, test_param_value)
 
130
INSTANTIATE_TEST_CASE_P(BasicNodeNames,
 
131
                        TestXPathParserParamNames,
 
132
                        ::testing::Values(
 
133
                            std::pair<std::string, bool>("a b", false),
 
134
                            std::pair<std::string, bool>("a*", false),
 
135
                            std::pair<std::string, bool>("HelloWorld", true),
 
136
                            std::pair<std::string, bool>("H", true),
 
137
                            std::pair<std::string, bool>("h", true),
 
138
                            std::pair<std::string, bool>("1", true),
 
139
                            std::pair<std::string, bool>("node-name", true),
 
140
                            std::pair<std::string, bool>("node_name", true),
 
141
                            std::pair<std::string, bool>("node\\name", true),
 
142
                            std::pair<std::string, bool>("node.name", false),
 
143
                            std::pair<std::string, bool>("node name", false)
 
144
                         ));
 
145
 
 
146
class TestXPathParserParamValues : public ::testing::TestWithParam<std::pair<std::string, bool> >
 
147
{
 
148
};
 
149
 
 
150
TEST_P(TestXPathParserParamValues, test_param_value)
91
151
{
92
152
    auto p = GetParam();
93
153
 
103
163
}
104
164
 
105
165
INSTANTIATE_TEST_CASE_P(BasicNodeNames,
106
 
                        TestXPathParser,
 
166
                        TestXPathParserParamValues,
107
167
                        ::testing::Values(
108
 
                            std::pair<std::string, bool>("a b", false),
 
168
                            std::pair<std::string, bool>("a b", true),
109
169
                            std::pair<std::string, bool>("a*", false),
110
170
                            std::pair<std::string, bool>("HelloWorld", true),
111
171
                            std::pair<std::string, bool>("H", true),
112
172
                            std::pair<std::string, bool>("h", true),
113
173
                            std::pair<std::string, bool>("1", true),
114
174
                            std::pair<std::string, bool>("node-name", true),
115
 
                            std::pair<std::string, bool>("node_name", true)
 
175
                            std::pair<std::string, bool>("node_name", true),
 
176
                            std::pair<std::string, bool>("node\\name", true),
 
177
                            std::pair<std::string, bool>("node name", true),
 
178
                            std::pair<std::string, bool>("node.name", true)
116
179
                         ));
117
180
 
118
 
TEST(TestXPathParser, test_node_name_accepts_wildcards)
 
181
 
 
182
TEST(TestXPathParser, test_wildcard_node_name_accepts_wildcards)
119
183
{
120
184
    std::string input("*");
121
185
 
122
186
    parser::xpath_grammar<std::string::iterator> g;
123
187
 
124
188
    std::string result;
125
 
    ASSERT_EQ( true,  test_parser_attr(input, g.node_name, result) );
 
189
    ASSERT_EQ( true,  test_parser_attr(input, g.wildcard_node_name, result) );
126
190
    ASSERT_EQ(input, result);
127
191
}
128
192
 
129
 
TEST(TestXPathParser, test_full_node)
130
 
{
131
 
    std::string input("node_name[param_name=123]");
132
 
 
133
 
    parser::xpath_grammar<std::string::iterator> g;
134
 
 
135
 
    xpathselect::XPathQueryPart result;
136
 
    ASSERT_EQ( true,  test_parser_attr(input, g.node, result) );
137
 
    ASSERT_EQ("node_name", result.node_name_);
138
 
    ASSERT_TRUE(result.parameter);
139
 
    ASSERT_EQ("param_name", result.parameter->param_name);
140
 
    ASSERT_EQ("123", result.parameter->param_value);
141
 
}
142
 
 
143
 
TEST(TestXPathParser, test_partial_node_name_only)
144
 
{
145
 
    std::string input("node_name");
146
 
 
147
 
    parser::xpath_grammar<std::string::iterator> g;
148
 
 
149
 
    xpathselect::XPathQueryPart result;
150
 
    ASSERT_EQ( true,  test_parser_attr(input, g.node, result) );
151
 
    ASSERT_EQ("node_name", result.node_name_);
152
 
    ASSERT_FALSE(result.parameter);
153
 
}
154
 
 
155
 
TEST(TestXPathParser, test_partial_node_wildcard)
156
 
{
157
 
    std::string input("*");
158
 
 
159
 
    parser::xpath_grammar<std::string::iterator> g;
160
 
 
161
 
    xpathselect::XPathQueryPart result;
162
 
    ASSERT_EQ( true,  test_parser_attr(input, g.node, result) );
163
 
    ASSERT_EQ("*", result.node_name_);
164
 
    ASSERT_FALSE(result.parameter);
165
 
}
166
 
 
167
 
TEST(TestXPathParser, test_full_node_wildcard)
168
 
{
169
 
    std::string input("*[param_name=123]");
170
 
 
171
 
    parser::xpath_grammar<std::string::iterator> g;
172
 
 
173
 
    xpathselect::XPathQueryPart result;
174
 
    ASSERT_EQ( true,  test_parser_attr(input, g.node, result) );
175
 
    ASSERT_EQ("*", result.node_name_);
176
 
    ASSERT_TRUE(result.parameter);
177
 
    ASSERT_EQ("param_name", result.parameter->param_name);
178
 
    ASSERT_EQ("123", result.parameter->param_value);
179
 
}
 
193
class TestXPathParserWildcardNodeName : public ::testing::TestWithParam<std::pair<std::string, bool> >
 
194
{
 
195
};
 
196
 
 
197
TEST_P(TestXPathParserWildcardNodeName, test_wildcard_node_name_rejects_everything_else)
 
198
{
 
199
    auto p = GetParam();
 
200
 
 
201
    std::string input = p.first;
 
202
    bool expect_pass = p.second;
 
203
 
 
204
    parser::xpath_grammar<std::string::iterator> g;
 
205
 
 
206
    std::string result;
 
207
    ASSERT_EQ( expect_pass,  test_parser_attr(input, g.wildcard_node_name, result) );
 
208
    if (expect_pass)
 
209
        ASSERT_EQ(input, result);
 
210
}
 
211
 
 
212
INSTANTIATE_TEST_CASE_P(BasicNodeNames,
 
213
                        TestXPathParserWildcardNodeName,
 
214
                        ::testing::Values(
 
215
                            std::pair<std::string, bool>("", false),
 
216
                            std::pair<std::string, bool>("* ", false),
 
217
                            std::pair<std::string, bool>("**", false),
 
218
                            std::pair<std::string, bool>(" ", false),
 
219
                            std::pair<std::string, bool>("8", false),
 
220
                            std::pair<std::string, bool>("\t", false),
 
221
                            std::pair<std::string, bool>("node-name", false),
 
222
                            std::pair<std::string, bool>("node_name", false),
 
223
                            std::pair<std::string, bool>("*", true)
 
224
                         ));
 
225
 
180
226
 
181
227
TEST(TestXPathParser, test_param_parser_works)
182
228
{
190
236
    ASSERT_EQ("value", result.param_value);
191
237
}
192
238
 
193
 
 
194
239
TEST(TestXPathParser, test_param_parser_fails)
195
240
{
196
241
    std::string input("name=");
201
246
    ASSERT_FALSE( test_parser_attr(input, g.param, result) );
202
247
}
203
248
 
204
 
TEST(TestXPathParser, test_search_node)
 
249
TEST(TestXPathParser, test_param_list_single_value)
 
250
{
 
251
    std::string input("[name=123]");
 
252
 
 
253
    parser::xpath_grammar<std::string::iterator> g;
 
254
 
 
255
    xpathselect::ParamList result;
 
256
    ASSERT_EQ( true,  test_parser_attr(input, g.param_list, result) );
 
257
    ASSERT_EQ(1, result.size());
 
258
    ASSERT_EQ("name", result.at(0).param_name);
 
259
    ASSERT_EQ("123", result.at(0).param_value);
 
260
}
 
261
 
 
262
TEST(TestXPathParser, test_param_list_two_values)
 
263
{
 
264
    std::string input("[name=value,other=foo]");
 
265
 
 
266
    parser::xpath_grammar<std::string::iterator> g;
 
267
 
 
268
    xpathselect::ParamList result;
 
269
    ASSERT_EQ( true,  test_parser_attr(input, g.param_list, result) );
 
270
    ASSERT_EQ(2, result.size());
 
271
    ASSERT_EQ("name", result.at(0).param_name);
 
272
    ASSERT_EQ("value", result.at(0).param_value);
 
273
    ASSERT_EQ("other", result.at(1).param_name);
 
274
    ASSERT_EQ("foo", result.at(1).param_value);
 
275
}
 
276
 
 
277
TEST(TestXPathParser, test_spec_node_with_parameter)
 
278
{
 
279
    std::string input("node_name[param_name=123]");
 
280
 
 
281
    parser::xpath_grammar<std::string::iterator> g;
 
282
 
 
283
    xpathselect::XPathQueryPart result;
 
284
    ASSERT_EQ( true,  test_parser_attr(input, g.spec_node, result) );
 
285
    ASSERT_EQ("node_name", result.node_name_);
 
286
    ASSERT_FALSE(result.parameter.empty());
 
287
    ASSERT_EQ("param_name", result.parameter.at(0).param_name);
 
288
    ASSERT_EQ("123", result.parameter.at(0).param_value);
 
289
}
 
290
 
 
291
TEST(TestXPathParser, test_spec_node_without_parameter)
 
292
{
 
293
    std::string input("node_name");
 
294
 
 
295
    parser::xpath_grammar<std::string::iterator> g;
 
296
 
 
297
    xpathselect::XPathQueryPart result;
 
298
    ASSERT_EQ( true,  test_parser_attr(input, g.spec_node, result) );
 
299
    ASSERT_EQ("node_name", result.node_name_);
 
300
    ASSERT_TRUE(result.parameter.empty());
 
301
}
 
302
 
 
303
TEST(TestXPathParser, test_wildcard_node)
 
304
{
 
305
    std::string input("*");
 
306
 
 
307
    parser::xpath_grammar<std::string::iterator> g;
 
308
 
 
309
    xpathselect::XPathQueryPart result;
 
310
    ASSERT_EQ( true,  test_parser_attr(input, g.wildcard_node, result) );
 
311
    ASSERT_EQ("*", result.node_name_);
 
312
    ASSERT_TRUE(result.parameter.empty());
 
313
}
 
314
 
 
315
TEST(TestXPathParser, test_wildcard_node_rejects_parameters)
 
316
{
 
317
    std::string input("*[foo=bar]");
 
318
 
 
319
    parser::xpath_grammar<std::string::iterator> g;
 
320
 
 
321
    xpathselect::XPathQueryPart result;
 
322
    ASSERT_FALSE( test_parser_attr(input, g.wildcard_node, result) );
 
323
}
 
324
 
 
325
TEST(TestXPathParser, test_wildcard_node_with_params)
 
326
{
 
327
    std::string input("*[param_name=123]");
 
328
 
 
329
    parser::xpath_grammar<std::string::iterator> g;
 
330
 
 
331
    xpathselect::XPathQueryPart result;
 
332
    ASSERT_EQ( true,  test_parser_attr(input, g.wildcard_node_with_params, result) );
 
333
    ASSERT_EQ("*", result.node_name_);
 
334
    ASSERT_FALSE(result.parameter.empty());
 
335
    ASSERT_EQ("param_name", result.parameter.at(0).param_name);
 
336
    ASSERT_EQ("123", result.parameter.at(0).param_value);
 
337
}
 
338
 
 
339
 
 
340
TEST(TestXPathParser, test_node_can_be_a_wildcard_node_with_params)
 
341
{
 
342
    std::string input("*[name=value]");
 
343
 
 
344
    parser::xpath_grammar<std::string::iterator> g;
 
345
 
 
346
    xpathselect::XPathQueryPart result;
 
347
    ASSERT_EQ( true,  test_parser_attr(input, g.node, result) );
 
348
    ASSERT_EQ( "*", result.node_name_ );
 
349
    ASSERT_EQ( xpathselect::XPathQueryPart::QueryPartType::Normal, result.Type() );
 
350
    ASSERT_EQ( 1, result.parameter.size() );
 
351
    ASSERT_EQ( "name", result.parameter.at(0).param_name );
 
352
    ASSERT_EQ( "value", result.parameter.at(0).param_value );
 
353
}
 
354
 
 
355
TEST(TestXPathParser, test_node_can_be_a_wildcard_node_without_params)
 
356
{
 
357
    std::string input("*");
 
358
 
 
359
    parser::xpath_grammar<std::string::iterator> g;
 
360
 
 
361
    xpathselect::XPathQueryPart result;
 
362
    ASSERT_EQ( true,  test_parser_attr(input, g.node, result) );
 
363
    ASSERT_EQ( "*", result.node_name_ );
 
364
    ASSERT_EQ( xpathselect::XPathQueryPart::QueryPartType::Normal, result.Type() );
 
365
}
 
366
 
 
367
TEST(TestXPathParser, test_node_can_be_a_spec_node_with_params)
 
368
{
 
369
    std::string input("foo[name=value]");
 
370
 
 
371
    parser::xpath_grammar<std::string::iterator> g;
 
372
 
 
373
    xpathselect::XPathQueryPart result;
 
374
    ASSERT_EQ( true,  test_parser_attr(input, g.node, result) );
 
375
    ASSERT_EQ( "foo", result.node_name_ );
 
376
    ASSERT_EQ( xpathselect::XPathQueryPart::QueryPartType::Normal, result.Type() );
 
377
    ASSERT_EQ( 1, result.parameter.size() );
 
378
    ASSERT_EQ( "name", result.parameter.at(0).param_name );
 
379
    ASSERT_EQ( "value", result.parameter.at(0).param_value );
 
380
}
 
381
 
 
382
TEST(TestXPathParser, test_node_can_be_a_spec_node_without_params)
 
383
{
 
384
    std::string input("foo");
 
385
 
 
386
    parser::xpath_grammar<std::string::iterator> g;
 
387
 
 
388
    xpathselect::XPathQueryPart result;
 
389
    ASSERT_EQ( true,  test_parser_attr(input, g.node, result) );
 
390
    ASSERT_EQ( "foo", result.node_name_ );
 
391
    ASSERT_EQ( xpathselect::XPathQueryPart::QueryPartType::Normal, result.Type() );
 
392
}
 
393
 
 
394
TEST(TestXPathParser, test_search_node_followed_by_normal_node)
205
395
{
206
396
    // the search_node grammar fails if it's at the end of the line, so we need
207
397
    // to give it some more data, even though we're not actually matching it.
215
405
    ASSERT_TRUE( result.Type() == xpathselect::XPathQueryPart::QueryPartType::Search );
216
406
}
217
407
 
 
408
TEST(TestXPathParser, test_search_node_followed_by_wildcard_node_with_parameters)
 
409
{
 
410
    // the search_node grammar fails if it's at the end of the line, so we need
 
411
    // to give it some more data, even though we're not actually matching it.
 
412
    std::string input("//*[foo=bar]");
 
413
    parser::xpath_grammar<std::string::iterator> g;
 
414
    xpathselect::XPathQueryPart result;
 
415
 
 
416
    // however, this means we can't use the test_parser_attr function, since it
 
417
    // returns false on a partial match. Use the parse(...) function directly:
 
418
    ASSERT_TRUE( parse(input.begin(), input.end(),g.search_node, result) );
 
419
    ASSERT_TRUE( result.Type() == xpathselect::XPathQueryPart::QueryPartType::Search );
 
420
}
 
421
 
218
422
TEST(TestXPathParser, test_search_node_cannot_have_parameters)
219
423
{
220
424
    std::string input("//[param_name=value]");
225
429
    ASSERT_FALSE( test_parser_attr(input, g.search_node, result) );
226
430
}
227
431
 
 
432
TEST(TestXPathParser, test_normal_sep_works)
 
433
{
 
434
    std::string input("/");
 
435
 
 
436
    parser::xpath_grammar<std::string::iterator> g;
 
437
 
 
438
    ASSERT_EQ( true,  test_parser_attr(input, g.normal_sep) );
 
439
}
 
440
 
 
441
TEST(TestXPathParser, test_normal_sep_does_not_match_search_node)
 
442
{
 
443
    std::string input("//");
 
444
 
 
445
    parser::xpath_grammar<std::string::iterator> g;
 
446
 
 
447
    ASSERT_FALSE( test_parser_attr(input, g.normal_sep) );
 
448
}
 
449
 
228
450
TEST(TestXPathParser, test_can_extract_query_list)
229
451
{
230
452
    std::string input("/node1/node2");
235
457
    ASSERT_TRUE(test_parser_attr(input, g.node_sequence, result));
236
458
    ASSERT_EQ(2, result.size());
237
459
    ASSERT_EQ("node1", result.at(0).node_name_);
238
 
    ASSERT_FALSE(result.at(0).parameter);
 
460
    ASSERT_TRUE(result.at(0).parameter.empty());
239
461
    ASSERT_EQ("node2", result.at(1).node_name_);
240
 
    ASSERT_FALSE(result.at(1).parameter);
 
462
    ASSERT_TRUE(result.at(1).parameter.empty());
241
463
}
242
464
 
243
465
TEST(TestXPathParser, test_can_extract_query_list_with_search)
250
472
    ASSERT_TRUE(test_parser_attr(input, g.node_sequence, result));
251
473
    ASSERT_EQ(2, result.size());
252
474
    ASSERT_TRUE(result.at(0).Type() == xpathselect::XPathQueryPart::QueryPartType::Search );
253
 
    ASSERT_FALSE(result.at(0).parameter);
 
475
    ASSERT_TRUE(result.at(1).Type() == xpathselect::XPathQueryPart::QueryPartType::Normal );
 
476
    ASSERT_TRUE(result.at(0).parameter.empty());
254
477
    ASSERT_EQ("node1", result.at(1).node_name_);
255
 
    ASSERT_FALSE(result.at(1).parameter);
 
478
    ASSERT_TRUE(result.at(1).parameter.empty());
256
479
}
257
480
 
258
481
TEST(TestXPathParser, test_mix_search_and_normal)
267
490
    ASSERT_EQ(3, result.size());
268
491
 
269
492
    ASSERT_EQ("node1", result.at(0).node_name_);
270
 
    ASSERT_FALSE(result.at(0).parameter);
 
493
    ASSERT_TRUE(result.at(0).Type() == xpathselect::XPathQueryPart::QueryPartType::Normal );
 
494
    ASSERT_TRUE(result.at(0).parameter.empty());
271
495
 
272
496
    ASSERT_TRUE(result.at(1).Type() == xpathselect::XPathQueryPart::QueryPartType::Search );
273
 
    ASSERT_FALSE(result.at(1).parameter);
 
497
    ASSERT_TRUE(result.at(1).parameter.empty());
274
498
 
275
499
    ASSERT_EQ("node2", result.at(2).node_name_);
276
 
    ASSERT_FALSE(result.at(2).parameter);
 
500
    ASSERT_TRUE(result.at(2).Type() == xpathselect::XPathQueryPart::QueryPartType::Normal );
 
501
    ASSERT_TRUE(result.at(2).parameter.empty());
277
502
}
278
503
 
279
504
TEST(TestXPathParser, test_mix_search_and_long_normal)
288
513
    ASSERT_EQ(4, result.size());
289
514
 
290
515
    ASSERT_EQ("node1", result.at(0).node_name_);
291
 
    ASSERT_FALSE(result.at(0).parameter);
 
516
    ASSERT_TRUE(result.at(0).parameter.empty());
292
517
 
293
518
    ASSERT_TRUE(result.at(1).Type() == xpathselect::XPathQueryPart::QueryPartType::Search );
294
 
    ASSERT_FALSE(result.at(1).parameter);
 
519
    ASSERT_TRUE(result.at(1).parameter.empty());
295
520
 
296
521
    ASSERT_EQ("node2", result.at(2).node_name_);
297
 
    ASSERT_TRUE(result.at(2).parameter);
298
 
    ASSERT_EQ("name", result.at(2).parameter->param_name);
299
 
    ASSERT_EQ("val", result.at(2).parameter->param_value);
 
522
    ASSERT_EQ(1, result.at(2).parameter.size());
 
523
    ASSERT_EQ("name", result.at(2).parameter.at(0).param_name);
 
524
    ASSERT_EQ("val", result.at(2).parameter.at(0).param_value);
300
525
 
301
526
    ASSERT_EQ("node3", result.at(3).node_name_);
302
 
    ASSERT_FALSE(result.at(3).parameter);
 
527
    ASSERT_TRUE(result.at(3).parameter.empty());
303
528
}
304
529
 
305
530
 
332
557
                            std::pair<std::string, bool>("//root", true),
333
558
                            std::pair<std::string, bool>("/root//node1/node2", true),
334
559
                            std::pair<std::string, bool>("/root[p=1]//node1[p=2]/node3", true),
 
560
                            std::pair<std::string, bool>("/root[p=1,n=2,d=e3]", true),
 
561
                            std::pair<std::string, bool>("//root[p=1,n=2,d=e3]", true),
 
562
                            std::pair<std::string, bool>("/Root//*[p=1]", true),
 
563
                            std::pair<std::string, bool>("/Root//*[p=1,v=sj,c=true]", true),
335
564
                            // queries that must not parse correctly:
336
565
                            std::pair<std::string, bool>("//", false),
337
566
                            std::pair<std::string, bool>("/root//", false),