1 //
2 // Automated Testing Framework (atf)
3 //
4 // Copyright (c) 2007 The NetBSD Foundation, Inc.
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions
9 // are met:
10 // 1. Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 // 2. Redistributions in binary form must reproduce the above copyright
13 // notice, this list of conditions and the following disclaimer in the
14 // documentation and/or other materials provided with the distribution.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 //
29
30 #include <sstream>
31
32 #include <atf-c++.hpp>
33
34 #include "parser.hpp"
35 #include "test_helpers.hpp"
36
37 // ------------------------------------------------------------------------
38 // Tests for the "parse_error" class.
39 // ------------------------------------------------------------------------
40
41 ATF_TEST_CASE(parse_error_to_string);
ATF_TEST_CASE_HEAD(parse_error_to_string)42 ATF_TEST_CASE_HEAD(parse_error_to_string)
43 {
44 set_md_var("descr", "Tests the parse_error conversion to strings");
45 }
ATF_TEST_CASE_BODY(parse_error_to_string)46 ATF_TEST_CASE_BODY(parse_error_to_string)
47 {
48 using tools::parser::parse_error;
49
50 const parse_error e(123, "This is the message");
51 ATF_REQUIRE_EQ("123: This is the message", std::string(e));
52 }
53
54 // ------------------------------------------------------------------------
55 // Tests for the "parse_errors" class.
56 // ------------------------------------------------------------------------
57
58 ATF_TEST_CASE(parse_errors_what);
ATF_TEST_CASE_HEAD(parse_errors_what)59 ATF_TEST_CASE_HEAD(parse_errors_what)
60 {
61 set_md_var("descr", "Tests the parse_errors description");
62 }
ATF_TEST_CASE_BODY(parse_errors_what)63 ATF_TEST_CASE_BODY(parse_errors_what)
64 {
65 using tools::parser::parse_error;
66 using tools::parser::parse_errors;
67
68 parse_errors es;
69 es.push_back(parse_error(2, "Second error"));
70 es.push_back(parse_error(1, "First error"));
71
72 ATF_REQUIRE_EQ("2: Second error\n1: First error", std::string(es.what()));
73 }
74
75 // ------------------------------------------------------------------------
76 // Tests for the "token" class.
77 // ------------------------------------------------------------------------
78
79 ATF_TEST_CASE(token_getters);
ATF_TEST_CASE_HEAD(token_getters)80 ATF_TEST_CASE_HEAD(token_getters)
81 {
82 set_md_var("descr", "Tests the token getters");
83 }
ATF_TEST_CASE_BODY(token_getters)84 ATF_TEST_CASE_BODY(token_getters)
85 {
86 using tools::parser::token;
87
88 {
89 token t(10, 0);
90 ATF_REQUIRE_EQ(t.lineno(), 10);
91 ATF_REQUIRE_EQ(t.type(), 0);
92 ATF_REQUIRE(t.text().empty());
93 }
94
95 {
96 token t(10, 0, "foo");
97 ATF_REQUIRE_EQ(t.lineno(), 10);
98 ATF_REQUIRE_EQ(t.type(), 0);
99 ATF_REQUIRE_EQ(t.text(), "foo");
100 }
101
102 {
103 token t(20, 1);
104 ATF_REQUIRE_EQ(t.lineno(), 20);
105 ATF_REQUIRE_EQ(t.type(), 1);
106 ATF_REQUIRE(t.text().empty());
107 }
108
109 {
110 token t(20, 1, "bar");
111 ATF_REQUIRE_EQ(t.lineno(), 20);
112 ATF_REQUIRE_EQ(t.type(), 1);
113 ATF_REQUIRE_EQ(t.text(), "bar");
114 }
115 }
116
117 // ------------------------------------------------------------------------
118 // Tests for the "tokenizer" class.
119 // ------------------------------------------------------------------------
120
121 #define EXPECT(tkz, ttype, ttext) \
122 do { \
123 tools::parser::token t = tkz.next(); \
124 ATF_REQUIRE(t.type() == ttype); \
125 ATF_REQUIRE_EQ(t.text(), ttext); \
126 } while (false);
127
128 namespace minimal {
129
130 static const tools::parser::token_type eof_type = 0;
131 static const tools::parser::token_type nl_type = 1;
132 static const tools::parser::token_type word_type = 2;
133
134 class tokenizer : public tools::parser::tokenizer< std::istream > {
135 public:
tokenizer(std::istream & is,bool skipws)136 tokenizer(std::istream& is, bool skipws) :
137 tools::parser::tokenizer< std::istream >
138 (is, skipws, eof_type, nl_type, word_type)
139 {
140 }
141 };
142
143 }
144
145 namespace delims {
146
147 static const tools::parser::token_type eof_type = 0;
148 static const tools::parser::token_type nl_type = 1;
149 static const tools::parser::token_type word_type = 2;
150 static const tools::parser::token_type plus_type = 3;
151 static const tools::parser::token_type minus_type = 4;
152 static const tools::parser::token_type equal_type = 5;
153
154 class tokenizer : public tools::parser::tokenizer< std::istream > {
155 public:
tokenizer(std::istream & is,bool skipws)156 tokenizer(std::istream& is, bool skipws) :
157 tools::parser::tokenizer< std::istream >
158 (is, skipws, eof_type, nl_type, word_type)
159 {
160 add_delim('+', plus_type);
161 add_delim('-', minus_type);
162 add_delim('=', equal_type);
163 }
164 };
165
166 }
167
168 namespace keywords {
169
170 static const tools::parser::token_type eof_type = 0;
171 static const tools::parser::token_type nl_type = 1;
172 static const tools::parser::token_type word_type = 2;
173 static const tools::parser::token_type var_type = 3;
174 static const tools::parser::token_type loop_type = 4;
175 static const tools::parser::token_type endloop_type = 5;
176
177 class tokenizer : public tools::parser::tokenizer< std::istream > {
178 public:
tokenizer(std::istream & is,bool skipws)179 tokenizer(std::istream& is, bool skipws) :
180 tools::parser::tokenizer< std::istream >
181 (is, skipws, eof_type, nl_type, word_type)
182 {
183 add_keyword("var", var_type);
184 add_keyword("loop", loop_type);
185 add_keyword("endloop", endloop_type);
186 }
187 };
188
189 }
190
191 namespace quotes {
192
193 static const tools::parser::token_type eof_type = 0;
194 static const tools::parser::token_type nl_type = 1;
195 static const tools::parser::token_type word_type = 2;
196 static const tools::parser::token_type dblquote_type = 3;
197
198 class tokenizer : public tools::parser::tokenizer< std::istream > {
199 public:
tokenizer(std::istream & is,bool skipws)200 tokenizer(std::istream& is, bool skipws) :
201 tools::parser::tokenizer< std::istream >
202 (is, skipws, eof_type, nl_type, word_type)
203 {
204 add_quote('"', dblquote_type);
205 }
206 };
207
208 }
209
210 ATF_TEST_CASE(tokenizer_minimal_nows);
ATF_TEST_CASE_HEAD(tokenizer_minimal_nows)211 ATF_TEST_CASE_HEAD(tokenizer_minimal_nows)
212 {
213 set_md_var("descr", "Tests the tokenizer class using a minimal parser "
214 "and not skipping whitespace");
215 }
ATF_TEST_CASE_BODY(tokenizer_minimal_nows)216 ATF_TEST_CASE_BODY(tokenizer_minimal_nows)
217 {
218 using namespace minimal;
219
220 {
221 std::istringstream iss("");
222 tokenizer mt(iss, false);
223
224 EXPECT(mt, eof_type, "<<EOF>>");
225 EXPECT(mt, eof_type, "<<EOF>>");
226 }
227
228 {
229 std::istringstream iss("\n");
230 tokenizer mt(iss, false);
231
232 EXPECT(mt, nl_type, "<<NEWLINE>>");
233 EXPECT(mt, eof_type, "<<EOF>>");
234 EXPECT(mt, eof_type, "<<EOF>>");
235 }
236
237 {
238 std::istringstream iss("\n\n\n");
239 tokenizer mt(iss, false);
240
241 EXPECT(mt, nl_type, "<<NEWLINE>>");
242 EXPECT(mt, nl_type, "<<NEWLINE>>");
243 EXPECT(mt, nl_type, "<<NEWLINE>>");
244 EXPECT(mt, eof_type, "<<EOF>>");
245 EXPECT(mt, eof_type, "<<EOF>>");
246 }
247
248 {
249 std::istringstream iss("line 1");
250 tokenizer mt(iss, false);
251
252 EXPECT(mt, word_type, "line 1");
253 EXPECT(mt, eof_type, "<<EOF>>");
254 EXPECT(mt, eof_type, "<<EOF>>");
255 }
256
257 {
258 std::istringstream iss("line 1\n");
259 tokenizer mt(iss, false);
260
261 EXPECT(mt, word_type, "line 1");
262 EXPECT(mt, nl_type, "<<NEWLINE>>");
263 EXPECT(mt, eof_type, "<<EOF>>");
264 EXPECT(mt, eof_type, "<<EOF>>");
265 }
266
267 {
268 std::istringstream iss("line 1\nline 2");
269 tokenizer mt(iss, false);
270
271 EXPECT(mt, word_type, "line 1");
272 EXPECT(mt, nl_type, "<<NEWLINE>>");
273 EXPECT(mt, word_type, "line 2");
274 EXPECT(mt, eof_type, "<<EOF>>");
275 EXPECT(mt, eof_type, "<<EOF>>");
276 }
277
278 {
279 std::istringstream iss("line 1\nline 2\nline 3\n");
280 tokenizer mt(iss, false);
281
282 EXPECT(mt, word_type, "line 1");
283 EXPECT(mt, nl_type, "<<NEWLINE>>");
284 EXPECT(mt, word_type, "line 2");
285 EXPECT(mt, nl_type, "<<NEWLINE>>");
286 EXPECT(mt, word_type, "line 3");
287 EXPECT(mt, nl_type, "<<NEWLINE>>");
288 EXPECT(mt, eof_type, "<<EOF>>");
289 EXPECT(mt, eof_type, "<<EOF>>");
290 }
291 }
292
293 ATF_TEST_CASE(tokenizer_minimal_ws);
ATF_TEST_CASE_HEAD(tokenizer_minimal_ws)294 ATF_TEST_CASE_HEAD(tokenizer_minimal_ws)
295 {
296 set_md_var("descr", "Tests the tokenizer class using a minimal parser "
297 "and skipping whitespace");
298 }
ATF_TEST_CASE_BODY(tokenizer_minimal_ws)299 ATF_TEST_CASE_BODY(tokenizer_minimal_ws)
300 {
301 using namespace minimal;
302
303 {
304 std::istringstream iss("");
305 minimal::tokenizer mt(iss, true);
306
307 EXPECT(mt, eof_type, "<<EOF>>");
308 EXPECT(mt, eof_type, "<<EOF>>");
309 }
310
311 {
312 std::istringstream iss(" \t ");
313 tokenizer mt(iss, true);
314
315 EXPECT(mt, eof_type, "<<EOF>>");
316 EXPECT(mt, eof_type, "<<EOF>>");
317 }
318
319 {
320 std::istringstream iss("\n");
321 tokenizer mt(iss, true);
322
323 EXPECT(mt, nl_type, "<<NEWLINE>>");
324 EXPECT(mt, eof_type, "<<EOF>>");
325 EXPECT(mt, eof_type, "<<EOF>>");
326 }
327
328 {
329 std::istringstream iss(" \t \n \t ");
330 tokenizer mt(iss, true);
331
332 EXPECT(mt, nl_type, "<<NEWLINE>>");
333 EXPECT(mt, eof_type, "<<EOF>>");
334 EXPECT(mt, eof_type, "<<EOF>>");
335 }
336
337 {
338 std::istringstream iss("\n\n\n");
339 tokenizer mt(iss, true);
340
341 EXPECT(mt, nl_type, "<<NEWLINE>>");
342 EXPECT(mt, nl_type, "<<NEWLINE>>");
343 EXPECT(mt, nl_type, "<<NEWLINE>>");
344 EXPECT(mt, eof_type, "<<EOF>>");
345 EXPECT(mt, eof_type, "<<EOF>>");
346 }
347
348 {
349 std::istringstream iss("line 1");
350 tokenizer mt(iss, true);
351
352 EXPECT(mt, word_type, "line");
353 EXPECT(mt, word_type, "1");
354 EXPECT(mt, eof_type, "<<EOF>>");
355 EXPECT(mt, eof_type, "<<EOF>>");
356 }
357
358 {
359 std::istringstream iss(" \tline\t 1\t");
360 tokenizer mt(iss, true);
361
362 EXPECT(mt, word_type, "line");
363 EXPECT(mt, word_type, "1");
364 EXPECT(mt, eof_type, "<<EOF>>");
365 EXPECT(mt, eof_type, "<<EOF>>");
366 }
367
368 {
369 std::istringstream iss("line 1\n");
370 tokenizer mt(iss, true);
371
372 EXPECT(mt, word_type, "line");
373 EXPECT(mt, word_type, "1");
374 EXPECT(mt, nl_type, "<<NEWLINE>>");
375 EXPECT(mt, eof_type, "<<EOF>>");
376 EXPECT(mt, eof_type, "<<EOF>>");
377 }
378
379 {
380 std::istringstream iss("line 1\nline 2");
381 tokenizer mt(iss, true);
382
383 EXPECT(mt, word_type, "line");
384 EXPECT(mt, word_type, "1");
385 EXPECT(mt, nl_type, "<<NEWLINE>>");
386 EXPECT(mt, word_type, "line");
387 EXPECT(mt, word_type, "2");
388 EXPECT(mt, eof_type, "<<EOF>>");
389 EXPECT(mt, eof_type, "<<EOF>>");
390 }
391
392 {
393 std::istringstream iss("line 1\nline 2\nline 3\n");
394 tokenizer mt(iss, true);
395
396 EXPECT(mt, word_type, "line");
397 EXPECT(mt, word_type, "1");
398 EXPECT(mt, nl_type, "<<NEWLINE>>");
399 EXPECT(mt, word_type, "line");
400 EXPECT(mt, word_type, "2");
401 EXPECT(mt, nl_type, "<<NEWLINE>>");
402 EXPECT(mt, word_type, "line");
403 EXPECT(mt, word_type, "3");
404 EXPECT(mt, nl_type, "<<NEWLINE>>");
405 EXPECT(mt, eof_type, "<<EOF>>");
406 EXPECT(mt, eof_type, "<<EOF>>");
407 }
408
409 {
410 std::istringstream iss(" \t line \t 1\n\tline\t2\n line 3 \n");
411 tokenizer mt(iss, true);
412
413 EXPECT(mt, word_type, "line");
414 EXPECT(mt, word_type, "1");
415 EXPECT(mt, nl_type, "<<NEWLINE>>");
416 EXPECT(mt, word_type, "line");
417 EXPECT(mt, word_type, "2");
418 EXPECT(mt, nl_type, "<<NEWLINE>>");
419 EXPECT(mt, word_type, "line");
420 EXPECT(mt, word_type, "3");
421 EXPECT(mt, nl_type, "<<NEWLINE>>");
422 EXPECT(mt, eof_type, "<<EOF>>");
423 EXPECT(mt, eof_type, "<<EOF>>");
424 }
425 }
426
427 ATF_TEST_CASE(tokenizer_delims_nows);
ATF_TEST_CASE_HEAD(tokenizer_delims_nows)428 ATF_TEST_CASE_HEAD(tokenizer_delims_nows)
429 {
430 set_md_var("descr", "Tests the tokenizer class using a parser with some "
431 "additional delimiters and not skipping whitespace");
432 }
ATF_TEST_CASE_BODY(tokenizer_delims_nows)433 ATF_TEST_CASE_BODY(tokenizer_delims_nows)
434 {
435 using namespace delims;
436
437 {
438 std::istringstream iss("+-=");
439 tokenizer mt(iss, false);
440
441 EXPECT(mt, plus_type, "+");
442 EXPECT(mt, minus_type, "-");
443 EXPECT(mt, equal_type, "=");
444 EXPECT(mt, eof_type, "<<EOF>>");
445 EXPECT(mt, eof_type, "<<EOF>>");
446 }
447
448 {
449 std::istringstream iss("+++");
450 tokenizer mt(iss, false);
451
452 EXPECT(mt, plus_type, "+");
453 EXPECT(mt, plus_type, "+");
454 EXPECT(mt, plus_type, "+");
455 EXPECT(mt, eof_type, "<<EOF>>");
456 EXPECT(mt, eof_type, "<<EOF>>");
457 }
458
459 {
460 std::istringstream iss("\n+\n++\n");
461 tokenizer mt(iss, false);
462
463 EXPECT(mt, nl_type, "<<NEWLINE>>");
464 EXPECT(mt, plus_type, "+");
465 EXPECT(mt, nl_type, "<<NEWLINE>>");
466 EXPECT(mt, plus_type, "+");
467 EXPECT(mt, plus_type, "+");
468 EXPECT(mt, nl_type, "<<NEWLINE>>");
469 EXPECT(mt, eof_type, "<<EOF>>");
470 EXPECT(mt, eof_type, "<<EOF>>");
471 }
472
473 {
474 std::istringstream iss("foo+bar=baz");
475 tokenizer mt(iss, false);
476
477 EXPECT(mt, word_type, "foo");
478 EXPECT(mt, plus_type, "+");
479 EXPECT(mt, word_type, "bar");
480 EXPECT(mt, equal_type, "=");
481 EXPECT(mt, word_type, "baz");
482 EXPECT(mt, eof_type, "<<EOF>>");
483 EXPECT(mt, eof_type, "<<EOF>>");
484 }
485
486 {
487 std::istringstream iss(" foo\t+\tbar = baz ");
488 tokenizer mt(iss, false);
489
490 EXPECT(mt, word_type, " foo\t");
491 EXPECT(mt, plus_type, "+");
492 EXPECT(mt, word_type, "\tbar ");
493 EXPECT(mt, equal_type, "=");
494 EXPECT(mt, word_type, " baz ");
495 EXPECT(mt, eof_type, "<<EOF>>");
496 EXPECT(mt, eof_type, "<<EOF>>");
497 }
498 }
499
500 ATF_TEST_CASE(tokenizer_delims_ws);
ATF_TEST_CASE_HEAD(tokenizer_delims_ws)501 ATF_TEST_CASE_HEAD(tokenizer_delims_ws)
502 {
503 set_md_var("descr", "Tests the tokenizer class using a parser with some "
504 "additional delimiters and skipping whitespace");
505 }
ATF_TEST_CASE_BODY(tokenizer_delims_ws)506 ATF_TEST_CASE_BODY(tokenizer_delims_ws)
507 {
508 using namespace delims;
509
510 {
511 std::istringstream iss(" foo\t+\tbar = baz ");
512 tokenizer mt(iss, true);
513
514 EXPECT(mt, word_type, "foo");
515 EXPECT(mt, plus_type, "+");
516 EXPECT(mt, word_type, "bar");
517 EXPECT(mt, equal_type, "=");
518 EXPECT(mt, word_type, "baz");
519 EXPECT(mt, eof_type, "<<EOF>>");
520 EXPECT(mt, eof_type, "<<EOF>>");
521 }
522 }
523
524 ATF_TEST_CASE(tokenizer_keywords_nows);
ATF_TEST_CASE_HEAD(tokenizer_keywords_nows)525 ATF_TEST_CASE_HEAD(tokenizer_keywords_nows)
526 {
527 set_md_var("descr", "Tests the tokenizer class using a parser with some "
528 "additional keywords and not skipping whitespace");
529 }
ATF_TEST_CASE_BODY(tokenizer_keywords_nows)530 ATF_TEST_CASE_BODY(tokenizer_keywords_nows)
531 {
532 using namespace keywords;
533
534 {
535 std::istringstream iss("var");
536 tokenizer mt(iss, false);
537
538 EXPECT(mt, var_type, "var");
539 EXPECT(mt, eof_type, "<<EOF>>");
540 EXPECT(mt, eof_type, "<<EOF>>");
541 }
542
543 {
544 std::istringstream iss("va");
545 tokenizer mt(iss, false);
546
547 EXPECT(mt, word_type, "va");
548 EXPECT(mt, eof_type, "<<EOF>>");
549 EXPECT(mt, eof_type, "<<EOF>>");
550 }
551
552 {
553 std::istringstream iss("vara");
554 tokenizer mt(iss, false);
555
556 EXPECT(mt, word_type, "vara");
557 EXPECT(mt, eof_type, "<<EOF>>");
558 EXPECT(mt, eof_type, "<<EOF>>");
559 }
560
561 {
562 std::istringstream iss("var ");
563 tokenizer mt(iss, false);
564
565 EXPECT(mt, word_type, "var ");
566 EXPECT(mt, eof_type, "<<EOF>>");
567 EXPECT(mt, eof_type, "<<EOF>>");
568 }
569
570 {
571 std::istringstream iss("var\nloop\nendloop");
572 tokenizer mt(iss, false);
573
574 EXPECT(mt, var_type, "var");
575 EXPECT(mt, nl_type, "<<NEWLINE>>");
576 EXPECT(mt, loop_type, "loop");
577 EXPECT(mt, nl_type, "<<NEWLINE>>");
578 EXPECT(mt, endloop_type, "endloop");
579 EXPECT(mt, eof_type, "<<EOF>>");
580 EXPECT(mt, eof_type, "<<EOF>>");
581 }
582 }
583
584 ATF_TEST_CASE(tokenizer_keywords_ws);
ATF_TEST_CASE_HEAD(tokenizer_keywords_ws)585 ATF_TEST_CASE_HEAD(tokenizer_keywords_ws)
586 {
587 set_md_var("descr", "Tests the tokenizer class using a parser with some "
588 "additional keywords and not skipping whitespace");
589 }
ATF_TEST_CASE_BODY(tokenizer_keywords_ws)590 ATF_TEST_CASE_BODY(tokenizer_keywords_ws)
591 {
592 using namespace keywords;
593
594 {
595 std::istringstream iss("var ");
596 tokenizer mt(iss, true);
597
598 EXPECT(mt, var_type, "var");
599 EXPECT(mt, eof_type, "<<EOF>>");
600 EXPECT(mt, eof_type, "<<EOF>>");
601 }
602
603 {
604 std::istringstream iss(" var \n\tloop\t\n \tendloop \t");
605 tokenizer mt(iss, true);
606
607 EXPECT(mt, var_type, "var");
608 EXPECT(mt, nl_type, "<<NEWLINE>>");
609 EXPECT(mt, loop_type, "loop");
610 EXPECT(mt, nl_type, "<<NEWLINE>>");
611 EXPECT(mt, endloop_type, "endloop");
612 EXPECT(mt, eof_type, "<<EOF>>");
613 EXPECT(mt, eof_type, "<<EOF>>");
614 }
615
616 {
617 std::istringstream iss("var loop endloop");
618 tokenizer mt(iss, true);
619
620 EXPECT(mt, var_type, "var");
621 EXPECT(mt, loop_type, "loop");
622 EXPECT(mt, endloop_type, "endloop");
623 EXPECT(mt, eof_type, "<<EOF>>");
624 EXPECT(mt, eof_type, "<<EOF>>");
625 }
626 }
627
628 ATF_TEST_CASE(tokenizer_quotes_nows);
ATF_TEST_CASE_HEAD(tokenizer_quotes_nows)629 ATF_TEST_CASE_HEAD(tokenizer_quotes_nows)
630 {
631 set_md_var("descr", "Tests the tokenizer class using a parser with "
632 "quoted strings and not skipping whitespace");
633 }
ATF_TEST_CASE_BODY(tokenizer_quotes_nows)634 ATF_TEST_CASE_BODY(tokenizer_quotes_nows)
635 {
636 using namespace quotes;
637
638 {
639 std::istringstream iss("var");
640 tokenizer mt(iss, false);
641
642 EXPECT(mt, word_type, "var");
643 EXPECT(mt, eof_type, "<<EOF>>");
644 EXPECT(mt, eof_type, "<<EOF>>");
645 }
646
647 {
648 std::istringstream iss("\"var\"");
649 tokenizer mt(iss, false);
650
651 EXPECT(mt, word_type, "var");
652 EXPECT(mt, eof_type, "<<EOF>>");
653 EXPECT(mt, eof_type, "<<EOF>>");
654 }
655
656 {
657 std::istringstream iss("var1\"var2\"");
658 tokenizer mt(iss, false);
659
660 EXPECT(mt, word_type, "var1");
661 EXPECT(mt, word_type, "var2");
662 EXPECT(mt, eof_type, "<<EOF>>");
663 EXPECT(mt, eof_type, "<<EOF>>");
664 }
665
666 {
667 std::istringstream iss("var1\" var2 \"");
668 tokenizer mt(iss, false);
669
670 EXPECT(mt, word_type, "var1");
671 EXPECT(mt, word_type, " var2 ");
672 EXPECT(mt, eof_type, "<<EOF>>");
673 EXPECT(mt, eof_type, "<<EOF>>");
674 }
675 }
676
677 ATF_TEST_CASE(tokenizer_quotes_ws);
ATF_TEST_CASE_HEAD(tokenizer_quotes_ws)678 ATF_TEST_CASE_HEAD(tokenizer_quotes_ws)
679 {
680 set_md_var("descr", "Tests the tokenizer class using a parser with "
681 "quoted strings and skipping whitespace");
682 }
ATF_TEST_CASE_BODY(tokenizer_quotes_ws)683 ATF_TEST_CASE_BODY(tokenizer_quotes_ws)
684 {
685 using namespace quotes;
686
687 {
688 std::istringstream iss(" var ");
689 tokenizer mt(iss, true);
690
691 EXPECT(mt, word_type, "var");
692 EXPECT(mt, eof_type, "<<EOF>>");
693 EXPECT(mt, eof_type, "<<EOF>>");
694 }
695
696 {
697 std::istringstream iss(" \"var\" ");
698 tokenizer mt(iss, true);
699
700 EXPECT(mt, word_type, "var");
701 EXPECT(mt, eof_type, "<<EOF>>");
702 EXPECT(mt, eof_type, "<<EOF>>");
703 }
704
705 {
706 std::istringstream iss(" var1 \"var2\" ");
707 tokenizer mt(iss, true);
708
709 EXPECT(mt, word_type, "var1");
710 EXPECT(mt, word_type, "var2");
711 EXPECT(mt, eof_type, "<<EOF>>");
712 EXPECT(mt, eof_type, "<<EOF>>");
713 }
714
715 {
716 std::istringstream iss(" var1 \" var2 \" ");
717 tokenizer mt(iss, true);
718
719 EXPECT(mt, word_type, "var1");
720 EXPECT(mt, word_type, " var2 ");
721 EXPECT(mt, eof_type, "<<EOF>>");
722 EXPECT(mt, eof_type, "<<EOF>>");
723 }
724 }
725
726 // ------------------------------------------------------------------------
727 // Tests for the headers parser.
728 // ------------------------------------------------------------------------
729
730 class header_reader {
731 std::istream& m_is;
732
733 public:
header_reader(std::istream & is)734 header_reader(std::istream& is) :
735 m_is(is)
736 {
737 }
738
739 void
read(void)740 read(void)
741 {
742 std::pair< size_t, tools::parser::headers_map > hml =
743 tools::parser::read_headers(m_is, 1);
744 tools::parser::validate_content_type(hml.second,
745 "application/X-atf-headers-test", 1234);
746 }
747
748 std::vector< std::string > m_calls;
749 };
750
751 ATF_TEST_CASE_WITHOUT_HEAD(headers_1);
ATF_TEST_CASE_BODY(headers_1)752 ATF_TEST_CASE_BODY(headers_1)
753 {
754 const char* input =
755 ""
756 ;
757
758 const char* exp_calls[] = {
759 NULL
760 };
761
762 const char* exp_errors[] = {
763 "1: Unexpected token `<<EOF>>'; expected a header name",
764 NULL
765 };
766
767 do_parser_test< header_reader >(input, exp_calls, exp_errors);
768 }
769
770 ATF_TEST_CASE_WITHOUT_HEAD(headers_2);
ATF_TEST_CASE_BODY(headers_2)771 ATF_TEST_CASE_BODY(headers_2)
772 {
773 const char* input =
774 "Content-Type\n"
775 ;
776
777 const char* exp_calls[] = {
778 NULL
779 };
780
781 const char* exp_errors[] = {
782 "1: Unexpected token `<<NEWLINE>>'; expected `:'",
783 NULL
784 };
785
786 do_parser_test< header_reader >(input, exp_calls, exp_errors);
787 }
788
789 ATF_TEST_CASE_WITHOUT_HEAD(headers_3);
ATF_TEST_CASE_BODY(headers_3)790 ATF_TEST_CASE_BODY(headers_3)
791 {
792 const char* input =
793 "Content-Type:\n"
794 ;
795
796 const char* exp_calls[] = {
797 NULL
798 };
799
800 const char* exp_errors[] = {
801 "1: Unexpected token `<<NEWLINE>>'; expected a textual value",
802 NULL
803 };
804
805 do_parser_test< header_reader >(input, exp_calls, exp_errors);
806 }
807
808 ATF_TEST_CASE_WITHOUT_HEAD(headers_4);
ATF_TEST_CASE_BODY(headers_4)809 ATF_TEST_CASE_BODY(headers_4)
810 {
811 const char* input =
812 "Content-Type: application/X-atf-headers-test\n"
813 ;
814
815 const char* exp_calls[] = {
816 NULL
817 };
818
819 const char* exp_errors[] = {
820 "2: Unexpected token `<<EOF>>'; expected a header name",
821 NULL
822 };
823
824 do_parser_test< header_reader >(input, exp_calls, exp_errors);
825 }
826
827 ATF_TEST_CASE_WITHOUT_HEAD(headers_5);
ATF_TEST_CASE_BODY(headers_5)828 ATF_TEST_CASE_BODY(headers_5)
829 {
830 const char* input =
831 "Content-Type: application/X-atf-headers-test;\n"
832 ;
833
834 const char* exp_calls[] = {
835 NULL
836 };
837
838 const char* exp_errors[] = {
839 "1: Unexpected token `<<NEWLINE>>'; expected an attribute name",
840 NULL
841 };
842
843 do_parser_test< header_reader >(input, exp_calls, exp_errors);
844 }
845
846 ATF_TEST_CASE_WITHOUT_HEAD(headers_6);
ATF_TEST_CASE_BODY(headers_6)847 ATF_TEST_CASE_BODY(headers_6)
848 {
849 const char* input =
850 "Content-Type: application/X-atf-headers-test; version\n"
851 ;
852
853 const char* exp_calls[] = {
854 NULL
855 };
856
857 const char* exp_errors[] = {
858 "1: Unexpected token `<<NEWLINE>>'; expected `='",
859 NULL
860 };
861
862 do_parser_test< header_reader >(input, exp_calls, exp_errors);
863 }
864
865 ATF_TEST_CASE_WITHOUT_HEAD(headers_7);
ATF_TEST_CASE_BODY(headers_7)866 ATF_TEST_CASE_BODY(headers_7)
867 {
868 const char* input =
869 "Content-Type: application/X-atf-headers-test; version=\n"
870 ;
871
872 const char* exp_calls[] = {
873 NULL
874 };
875
876 const char* exp_errors[] = {
877 "1: Unexpected token `<<NEWLINE>>'; expected word or quoted string",
878 NULL
879 };
880
881 do_parser_test< header_reader >(input, exp_calls, exp_errors);
882 }
883
884 ATF_TEST_CASE_WITHOUT_HEAD(headers_8);
ATF_TEST_CASE_BODY(headers_8)885 ATF_TEST_CASE_BODY(headers_8)
886 {
887 const char* input =
888 "Content-Type: application/X-atf-headers-test; version=\"1234\n"
889 ;
890
891 const char* exp_calls[] = {
892 NULL
893 };
894
895 const char* exp_errors[] = {
896 "1: Missing double quotes before end of line",
897 NULL
898 };
899
900 do_parser_test< header_reader >(input, exp_calls, exp_errors);
901 }
902
903 ATF_TEST_CASE_WITHOUT_HEAD(headers_9);
ATF_TEST_CASE_BODY(headers_9)904 ATF_TEST_CASE_BODY(headers_9)
905 {
906 const char* input =
907 "Content-Type: application/X-atf-headers-test; version=1234\"\n"
908 ;
909
910 const char* exp_calls[] = {
911 NULL
912 };
913
914 const char* exp_errors[] = {
915 "1: Missing double quotes before end of line",
916 NULL
917 };
918
919 do_parser_test< header_reader >(input, exp_calls, exp_errors);
920 }
921
922 ATF_TEST_CASE_WITHOUT_HEAD(headers_10);
ATF_TEST_CASE_BODY(headers_10)923 ATF_TEST_CASE_BODY(headers_10)
924 {
925 const char* input =
926 "Content-Type: application/X-atf-headers-test; version=1234\n"
927 ;
928
929 const char* exp_calls[] = {
930 NULL
931 };
932
933 const char* exp_errors[] = {
934 "2: Unexpected token `<<EOF>>'; expected a header name",
935 NULL
936 };
937
938 do_parser_test< header_reader >(input, exp_calls, exp_errors);
939 }
940
941 ATF_TEST_CASE_WITHOUT_HEAD(headers_11);
ATF_TEST_CASE_BODY(headers_11)942 ATF_TEST_CASE_BODY(headers_11)
943 {
944 const char* input =
945 "Content-Type: application/X-atf-headers-test; version=\"1234\"\n"
946 ;
947
948 const char* exp_calls[] = {
949 NULL
950 };
951
952 const char* exp_errors[] = {
953 "2: Unexpected token `<<EOF>>'; expected a header name",
954 NULL
955 };
956
957 do_parser_test< header_reader >(input, exp_calls, exp_errors);
958 }
959
960 ATF_TEST_CASE_WITHOUT_HEAD(headers_12);
ATF_TEST_CASE_BODY(headers_12)961 ATF_TEST_CASE_BODY(headers_12)
962 {
963 const char* input =
964 "Content-Type: application/X-atf-headers-test; version=\"1234\"\n"
965 "a b\n"
966 "a-b:\n"
967 "a-b: foo;\n"
968 "a-b: foo; var\n"
969 "a-b: foo; var=\n"
970 "a-b: foo; var=\"a\n"
971 "a-b: foo; var=a\"\n"
972 "a-b: foo; var=\"a\";\n"
973 "a-b: foo; var=\"a\"; second\n"
974 "a-b: foo; var=\"a\"; second=\n"
975 "a-b: foo; var=\"a\"; second=\"b\n"
976 "a-b: foo; var=\"a\"; second=b\"\n"
977 "a-b: foo; var=\"a\"; second=\"b\"\n"
978 ;
979
980 const char* exp_calls[] = {
981 NULL
982 };
983
984 const char* exp_errors[] = {
985 "2: Unexpected token `b'; expected `:'",
986 "3: Unexpected token `<<NEWLINE>>'; expected a textual value",
987 "4: Unexpected token `<<NEWLINE>>'; expected an attribute name",
988 "5: Unexpected token `<<NEWLINE>>'; expected `='",
989 "6: Unexpected token `<<NEWLINE>>'; expected word or quoted string",
990 "7: Missing double quotes before end of line",
991 "8: Missing double quotes before end of line",
992 "9: Unexpected token `<<NEWLINE>>'; expected an attribute name",
993 "10: Unexpected token `<<NEWLINE>>'; expected `='",
994 "11: Unexpected token `<<NEWLINE>>'; expected word or quoted string",
995 "12: Missing double quotes before end of line",
996 "13: Missing double quotes before end of line",
997 NULL
998 };
999
1000 do_parser_test< header_reader >(input, exp_calls, exp_errors);
1001 }
1002
1003 // ------------------------------------------------------------------------
1004 // Main.
1005 // ------------------------------------------------------------------------
1006
ATF_INIT_TEST_CASES(tcs)1007 ATF_INIT_TEST_CASES(tcs)
1008 {
1009 // Add test cases for the "parse_error" class.
1010 ATF_ADD_TEST_CASE(tcs, parse_error_to_string);
1011
1012 // Add test cases for the "parse_errors" class.
1013 ATF_ADD_TEST_CASE(tcs, parse_errors_what);
1014
1015 // Add test cases for the "token" class.
1016 ATF_ADD_TEST_CASE(tcs, token_getters);
1017
1018 // Add test cases for the "tokenizer" class.
1019 ATF_ADD_TEST_CASE(tcs, tokenizer_minimal_nows);
1020 ATF_ADD_TEST_CASE(tcs, tokenizer_minimal_ws);
1021 ATF_ADD_TEST_CASE(tcs, tokenizer_delims_nows);
1022 ATF_ADD_TEST_CASE(tcs, tokenizer_delims_ws);
1023 ATF_ADD_TEST_CASE(tcs, tokenizer_keywords_nows);
1024 ATF_ADD_TEST_CASE(tcs, tokenizer_keywords_ws);
1025 ATF_ADD_TEST_CASE(tcs, tokenizer_quotes_nows);
1026 ATF_ADD_TEST_CASE(tcs, tokenizer_quotes_ws);
1027
1028 // Add the tests for the headers parser.
1029
1030 // Add the test cases for the header file.
1031 ATF_ADD_TEST_CASE(tcs, headers_1);
1032 ATF_ADD_TEST_CASE(tcs, headers_2);
1033 ATF_ADD_TEST_CASE(tcs, headers_3);
1034 ATF_ADD_TEST_CASE(tcs, headers_4);
1035 ATF_ADD_TEST_CASE(tcs, headers_5);
1036 ATF_ADD_TEST_CASE(tcs, headers_6);
1037 ATF_ADD_TEST_CASE(tcs, headers_7);
1038 ATF_ADD_TEST_CASE(tcs, headers_8);
1039 ATF_ADD_TEST_CASE(tcs, headers_9);
1040 ATF_ADD_TEST_CASE(tcs, headers_10);
1041 ATF_ADD_TEST_CASE(tcs, headers_11);
1042 ATF_ADD_TEST_CASE(tcs, headers_12);
1043 }
1044