external/bsd/atf/dist/tools/reader_test.cpp

   1 //
   2 // Automated Testing Framework (atf)
   3 //
   4 // Copyright (c) 2010 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 <iostream>
  31 #include <sstream>
  32 #include <string>
  33 #include <utility>
  34 #include <vector>
  35
  36 #include <atf-c++.hpp>
  37
  38 #include "parser.hpp"
  39 #include "reader.hpp"
  40 #include "test_helpers.hpp"
  41 #include "text.hpp"
  42
  43 namespace impl = tools::atf_report;
  44
  45 class tps_reader : protected impl::atf_tps_reader {
  46     void
  47     got_info(const std::string& what, const std::string& val)
  48     {
  49         m_calls.push_back("got_info(" + what + ", " + val + ")");
  50     }
  51
  52     void
  53     got_ntps(size_t ntps)
  54     {
  55         m_calls.push_back("got_ntps(" + tools::text::to_string(ntps) + ")");
  56     }
  57
  58     void
  59     got_tp_start(const std::string& tpname, size_t ntcs)
  60     {
  61         m_calls.push_back("got_tp_start(" + tpname + ", " +
  62                           tools::text::to_string(ntcs) + ")");
  63     }
  64
  65     void
  66     got_tp_end(struct timeval* tv __attribute__((__unused__)),
  67                const std::string& reason)
  68     {
  69         m_calls.push_back("got_tp_end(" + reason + ")");
  70     }
  71
  72     void
  73     got_tc_start(const std::string& tcname)
  74     {
  75         m_calls.push_back("got_tc_start(" + tcname + ")");
  76     }
  77
  78     void
  79     got_tc_end(const std::string& state,
  80                struct timeval* tv __attribute__((__unused__)),
  81                const std::string& reason)
  82     {
  83         const std::string r = state + (reason.empty() ? "" : ", " + reason);
  84         m_calls.push_back("got_tc_end(" + r + ")");
  85     }
  86
  87     void
  88     got_tc_stdout_line(const std::string& line)
  89     {
  90         m_calls.push_back("got_tc_stdout_line(" + line + ")");
  91     }
  92
  93     void
  94     got_tc_stderr_line(const std::string& line)
  95     {
  96         m_calls.push_back("got_tc_stderr_line(" + line + ")");
  97     }
  98
  99     void
 100     got_eof(void)
 101     {
 102         m_calls.push_back("got_eof()");
 103     }
 104
 105 public:
 106     tps_reader(std::istream& is) :
 107         impl::atf_tps_reader(is)
 108     {
 109     }
 110
 111     void
 112     read(void)
 113     {
 114         atf_tps_reader::read();
 115     }
 116
 117     std::vector< std::string > m_calls;
 118 };
 119
 120 ATF_TEST_CASE_WITHOUT_HEAD(tps_1);
 121 ATF_TEST_CASE_BODY(tps_1)
 122 {
 123     const char* input =
 124         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 125         "\n"
 126         "tps-count: 0\n"
 127     ;
 128
 129     const char* exp_calls[] = {
 130         "got_ntps(0)",
 131         "got_eof()",
 132         NULL
 133     };
 134
 135     const char* exp_errors[] = {
 136         NULL
 137     };
 138
 139     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 140 }
 141
 142 ATF_TEST_CASE_WITHOUT_HEAD(tps_2);
 143 ATF_TEST_CASE_BODY(tps_2)
 144 {
 145     const char* input =
 146         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 147         "\n"
 148         "tps-count: 2\n"
 149         "tp-start: 123.456, first-prog, 0\n"
 150         "tp-end: 123.567, first-prog\n"
 151         "tp-start: 123.678, second-prog, 0\n"
 152         "tp-end: 123.789, second-prog, This program failed\n"
 153     ;
 154
 155     const char* exp_calls[] = {
 156         "got_ntps(2)",
 157         "got_tp_start(first-prog, 0)",
 158         "got_tp_end()",
 159         "got_tp_start(second-prog, 0)",
 160         "got_tp_end(This program failed)",
 161         "got_eof()",
 162         NULL
 163     };
 164
 165     const char* exp_errors[] = {
 166         NULL
 167     };
 168
 169     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 170 }
 171
 172 ATF_TEST_CASE_WITHOUT_HEAD(tps_3);
 173 ATF_TEST_CASE_BODY(tps_3)
 174 {
 175     const char* input =
 176         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 177         "\n"
 178         "tps-count: 2\n"
 179         "tp-start: 123.123, first-prog, 3\n"
 180         "tc-start: 123.234, first-test\n"
 181         "tc-end: 123.345, first-test, passed\n"
 182         "tc-start: 123.456, second-test\n"
 183         "tc-end: 123.567, second-test, skipped, Testing skipped reason\n"
 184         "tc-start: 123.678, third.test\n"
 185         "tc-end: 123.789, third.test, failed, Testing failed reason\n"
 186         "tp-end: 123.890, first-prog\n"
 187         "tp-start: 124.901, second-prog, 3\n"
 188         "tc-start: 124.1012, first-test\n"
 189         "tc-so:first stdout line for 1st test\n"
 190         "tc-se:first stderr line for 1st test\n"
 191         "tc-so:second stdout line for 1st test\n"
 192         "tc-se:second stderr line for 1st test\n"
 193         "tc-end: 124.1123, first-test, passed\n"
 194         "tc-start: 124.1234, second-test\n"
 195         "tc-so:first stdout line for 2nd test\n"
 196         "tc-se:first stderr line for 2nd test\n"
 197         "tc-so:second stdout line for 2nd test\n"
 198         "tc-se:second stderr line for 2nd test\n"
 199         "tc-end: 124.1345, second-test, skipped, Testing skipped reason\n"
 200         "tc-start: 124.1456, third.test\n"
 201         "tc-so:first stdout line for 3rd test\n"
 202         "tc-se:first stderr line for 3rd test\n"
 203         "tc-so:second stdout line for 3rd test\n"
 204         "tc-se:second stderr line for 3rd test\n"
 205         "tc-end: 124.1567, third.test, failed, Testing failed reason\n"
 206         "tp-end: 124.1678, second-prog, This program failed\n"
 207     ;
 208
 209     const char* exp_calls[] = {
 210         "got_ntps(2)",
 211         "got_tp_start(first-prog, 3)",
 212         "got_tc_start(first-test)",
 213         "got_tc_end(passed)",
 214         "got_tc_start(second-test)",
 215         "got_tc_end(skipped, Testing skipped reason)",
 216         "got_tc_start(third.test)",
 217         "got_tc_end(failed, Testing failed reason)",
 218         "got_tp_end()",
 219         "got_tp_start(second-prog, 3)",
 220         "got_tc_start(first-test)",
 221         "got_tc_stdout_line(first stdout line for 1st test)",
 222         "got_tc_stderr_line(first stderr line for 1st test)",
 223         "got_tc_stdout_line(second stdout line for 1st test)",
 224         "got_tc_stderr_line(second stderr line for 1st test)",
 225         "got_tc_end(passed)",
 226         "got_tc_start(second-test)",
 227         "got_tc_stdout_line(first stdout line for 2nd test)",
 228         "got_tc_stderr_line(first stderr line for 2nd test)",
 229         "got_tc_stdout_line(second stdout line for 2nd test)",
 230         "got_tc_stderr_line(second stderr line for 2nd test)",
 231         "got_tc_end(skipped, Testing skipped reason)",
 232         "got_tc_start(third.test)",
 233         "got_tc_stdout_line(first stdout line for 3rd test)",
 234         "got_tc_stderr_line(first stderr line for 3rd test)",
 235         "got_tc_stdout_line(second stdout line for 3rd test)",
 236         "got_tc_stderr_line(second stderr line for 3rd test)",
 237         "got_tc_end(failed, Testing failed reason)",
 238         "got_tp_end(This program failed)",
 239         "got_eof()",
 240         NULL
 241     };
 242
 243     const char* exp_errors[] = {
 244         NULL
 245     };
 246
 247     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 248 }
 249
 250 ATF_TEST_CASE_WITHOUT_HEAD(tps_4);
 251 ATF_TEST_CASE_BODY(tps_4)
 252 {
 253     const char* input =
 254         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 255         "\n"
 256         "info: a, foo\n"
 257         "info: b, bar\n"
 258         "info: c, baz\n"
 259         "tps-count: 2\n"
 260         "tp-start: 234.1, first-prog, 3\n"
 261         "tc-start: 234.12, first-test\n"
 262         "tc-end: 234.23, first-test, passed\n"
 263         "tc-start: 234.34, second-test\n"
 264         "tc-end: 234.45, second-test, skipped, Testing skipped reason\n"
 265         "tc-start: 234.56, third-test\n"
 266         "tc-end: 234.67, third-test, failed, Testing failed reason\n"
 267         "tp-end: 234.78, first-prog\n"
 268         "tp-start: 234.89, second-prog, 3\n"
 269         "tc-start: 234.90, first-test\n"
 270         "tc-so:first stdout line for 1st test\n"
 271         "tc-se:first stderr line for 1st test\n"
 272         "tc-so:second stdout line for 1st test\n"
 273         "tc-se:second stderr line for 1st test\n"
 274         "tc-end: 234.101, first-test, passed\n"
 275         "tc-start: 234.112, second-test\n"
 276         "tc-so:first stdout line for 2nd test\n"
 277         "tc-se:first stderr line for 2nd test\n"
 278         "tc-so:second stdout line for 2nd test\n"
 279         "tc-se:second stderr line for 2nd test\n"
 280         "tc-end: 234.123, second-test, skipped, Testing skipped reason\n"
 281         "tc-start: 234.134, third-test\n"
 282         "tc-so:first stdout line for 3rd test\n"
 283         "tc-se:first stderr line for 3rd test\n"
 284         "tc-so:second stdout line for 3rd test\n"
 285         "tc-se:second stderr line for 3rd test\n"
 286         "tc-end: 234.145, third-test, failed, Testing failed reason\n"
 287         "tp-end: 234.156, second-prog, This program failed\n"
 288         "info: d, foo\n"
 289         "info: e, bar\n"
 290         "info: f, baz\n"
 291     ;
 292
 293     const char* exp_calls[] = {
 294         "got_info(a, foo)",
 295         "got_info(b, bar)",
 296         "got_info(c, baz)",
 297         "got_ntps(2)",
 298         "got_tp_start(first-prog, 3)",
 299         "got_tc_start(first-test)",
 300         "got_tc_end(passed)",
 301         "got_tc_start(second-test)",
 302         "got_tc_end(skipped, Testing skipped reason)",
 303         "got_tc_start(third-test)",
 304         "got_tc_end(failed, Testing failed reason)",
 305         "got_tp_end()",
 306         "got_tp_start(second-prog, 3)",
 307         "got_tc_start(first-test)",
 308         "got_tc_stdout_line(first stdout line for 1st test)",
 309         "got_tc_stderr_line(first stderr line for 1st test)",
 310         "got_tc_stdout_line(second stdout line for 1st test)",
 311         "got_tc_stderr_line(second stderr line for 1st test)",
 312         "got_tc_end(passed)",
 313         "got_tc_start(second-test)",
 314         "got_tc_stdout_line(first stdout line for 2nd test)",
 315         "got_tc_stderr_line(first stderr line for 2nd test)",
 316         "got_tc_stdout_line(second stdout line for 2nd test)",
 317         "got_tc_stderr_line(second stderr line for 2nd test)",
 318         "got_tc_end(skipped, Testing skipped reason)",
 319         "got_tc_start(third-test)",
 320         "got_tc_stdout_line(first stdout line for 3rd test)",
 321         "got_tc_stderr_line(first stderr line for 3rd test)",
 322         "got_tc_stdout_line(second stdout line for 3rd test)",
 323         "got_tc_stderr_line(second stderr line for 3rd test)",
 324         "got_tc_end(failed, Testing failed reason)",
 325         "got_tp_end(This program failed)",
 326         "got_info(d, foo)",
 327         "got_info(e, bar)",
 328         "got_info(f, baz)",
 329         "got_eof()",
 330         NULL
 331     };
 332
 333     const char* exp_errors[] = {
 334         NULL
 335     };
 336
 337     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 338 }
 339
 340 ATF_TEST_CASE_WITHOUT_HEAD(tps_5);
 341 ATF_TEST_CASE_BODY(tps_5)
 342 {
 343     const char* input =
 344         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 345         "\n"
 346         "tps-count: 1\n"
 347         "tp-start: 345.123, the-prog, 1\n"
 348         "tc-start: 345.134, the-test\n"
 349         "tc-so:--- a    2007-11-04 14:00:41.000000000 +0100\n"
 350         "tc-so:+++ b    2007-11-04 14:00:48.000000000 +0100\n"
 351         "tc-so:@@ -1,7 +1,7 @@\n"
 352         "tc-so: This test is meant to simulate a diff.\n"
 353         "tc-so: Blank space at beginning of context lines must be preserved.\n"
 354         "tc-so: \n"
 355         "tc-so:-First original line.\n"
 356         "tc-so:-Second original line.\n"
 357         "tc-so:+First modified line.\n"
 358         "tc-so:+Second modified line.\n"
 359         "tc-so: \n"
 360         "tc-so: EOF\n"
 361         "tc-end: 345.145, the-test, passed\n"
 362         "tp-end: 345.156, the-prog\n"
 363     ;
 364
 365     // NO_CHECK_STYLE_BEGIN
 366     const char* exp_calls[] = {
 367         "got_ntps(1)",
 368         "got_tp_start(the-prog, 1)",
 369         "got_tc_start(the-test)",
 370         "got_tc_stdout_line(--- a       2007-11-04 14:00:41.000000000 +0100)",
 371         "got_tc_stdout_line(+++ b       2007-11-04 14:00:48.000000000 +0100)",
 372         "got_tc_stdout_line(@@ -1,7 +1,7 @@)",
 373         "got_tc_stdout_line( This test is meant to simulate a diff.)",
 374         "got_tc_stdout_line( Blank space at beginning of context lines must be preserved.)",
 375         "got_tc_stdout_line( )",
 376         "got_tc_stdout_line(-First original line.)",
 377         "got_tc_stdout_line(-Second original line.)",
 378         "got_tc_stdout_line(+First modified line.)",
 379         "got_tc_stdout_line(+Second modified line.)",
 380         "got_tc_stdout_line( )",
 381         "got_tc_stdout_line( EOF)",
 382         "got_tc_end(passed)",
 383         "got_tp_end()",
 384         "got_eof()",
 385         NULL
 386     };
 387     // NO_CHECK_STYLE_END
 388
 389     const char* exp_errors[] = {
 390         NULL
 391     };
 392
 393     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 394 }
 395
 396 ATF_TEST_CASE_WITHOUT_HEAD(tps_6);
 397 ATF_TEST_CASE_BODY(tps_6)
 398 {
 399     const char* input =
 400         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 401         "\n"
 402         "tps-count: 1\n"
 403         "tp-start: 321.1, the-prog, 8\n"
 404         "tc-start: 321.12, one\n"
 405         "tc-end: 321.23, one, expected_death, The reason\n"
 406         "tc-start: 321.34, two\n"
 407         "tc-end: 321.45, two, expected_exit, This would be an exit\n"
 408         "tc-start: 321.56, three\n"
 409         "tc-end: 321.67, three, expected_failure, And this a failure\n"
 410         "tc-start: 321.78, four\n"
 411         "tc-end: 321.89, four, expected_signal, And this a signal\n"
 412         "tc-start: 321.90, five\n"
 413         "tc-end: 321.101, five, failed, Another reason\n"
 414         "tc-start: 321.112, six\n"
 415         "tc-end: 321.123, six, passed\n"
 416         "tc-start: 321.134, seven\n"
 417         "tc-end: 321.145, seven, skipped, Skipping it\n"
 418         "tc-start: 321.156, eight\n"
 419         "tc-end: 321.167, eight, expected_timeout, Some hang reason\n"
 420         "tp-end: 321.178, the-prog\n"
 421     ;
 422
 423     // NO_CHECK_STYLE_BEGIN
 424     const char* exp_calls[] = {
 425         "got_ntps(1)",
 426         "got_tp_start(the-prog, 8)",
 427         "got_tc_start(one)",
 428         "got_tc_end(expected_death, The reason)",
 429         "got_tc_start(two)",
 430         "got_tc_end(expected_exit, This would be an exit)",
 431         "got_tc_start(three)",
 432         "got_tc_end(expected_failure, And this a failure)",
 433         "got_tc_start(four)",
 434         "got_tc_end(expected_signal, And this a signal)",
 435         "got_tc_start(five)",
 436         "got_tc_end(failed, Another reason)",
 437         "got_tc_start(six)",
 438         "got_tc_end(passed)",
 439         "got_tc_start(seven)",
 440         "got_tc_end(skipped, Skipping it)",
 441         "got_tc_start(eight)",
 442         "got_tc_end(expected_timeout, Some hang reason)",
 443         "got_tp_end()",
 444         "got_eof()",
 445         NULL
 446     };
 447     // NO_CHECK_STYLE_END
 448
 449     const char* exp_errors[] = {
 450         NULL
 451     };
 452
 453     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 454 }
 455
 456
 457 ATF_TEST_CASE_WITHOUT_HEAD(tps_50);
 458 ATF_TEST_CASE_BODY(tps_50)
 459 {
 460     const char* input =
 461         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 462         "\n"
 463         "foo\n"
 464     ;
 465
 466     const char* exp_calls[] = {
 467         NULL
 468     };
 469
 470     const char* exp_errors[] = {
 471         "3: Unexpected token `foo'; expected tps-count or info field",
 472         NULL
 473     };
 474
 475     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 476 }
 477
 478 ATF_TEST_CASE_WITHOUT_HEAD(tps_51);
 479 ATF_TEST_CASE_BODY(tps_51)
 480 {
 481     const char* input =
 482         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 483         "\n"
 484         "tps-count\n"
 485     ;
 486
 487     const char* exp_calls[] = {
 488         NULL
 489     };
 490
 491     const char* exp_errors[] = {
 492         "3: Unexpected token `<<NEWLINE>>'; expected `:'",
 493         NULL
 494     };
 495
 496     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 497 }
 498
 499 ATF_TEST_CASE_WITHOUT_HEAD(tps_52);
 500 ATF_TEST_CASE_BODY(tps_52)
 501 {
 502     const char* input =
 503         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 504         "\n"
 505         "tps-count:\n"
 506     ;
 507
 508     const char* exp_calls[] = {
 509         NULL
 510     };
 511
 512     const char* exp_errors[] = {
 513         "3: Unexpected token `<<NEWLINE>>'; expected number of test programs",
 514         NULL
 515     };
 516
 517     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 518 }
 519
 520 ATF_TEST_CASE_WITHOUT_HEAD(tps_53);
 521 ATF_TEST_CASE_BODY(tps_53)
 522 {
 523     const char* input =
 524         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 525         "\n"
 526         "tps-count: 1\n"
 527         "foo\n"
 528     ;
 529
 530     const char* exp_calls[] = {
 531         "got_ntps(1)",
 532         NULL
 533     };
 534
 535     const char* exp_errors[] = {
 536         "4: Unexpected token `foo'; expected start of test program",
 537         NULL
 538     };
 539
 540     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 541 }
 542
 543 ATF_TEST_CASE_WITHOUT_HEAD(tps_54);
 544 ATF_TEST_CASE_BODY(tps_54)
 545 {
 546     const char* input =
 547         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 548         "\n"
 549         "tps-count: 1\n"
 550         "foo\n"
 551         "tp-start\n"
 552         "tp-start:\n"
 553         "tp-start: 123\n"
 554         "tp-start: 123.\n"
 555         "tp-start: 123.456\n"
 556         "tp-start: 123.456,\n"
 557         "tp-start: 123.456, foo\n"
 558         "tp-start: 123.456, foo,\n"
 559         "tp-start: 123.456, foo, 0\n"
 560         "bar\n"
 561         "tp-start: 456.789, foo, 0\n"
 562         "tp-end\n"
 563         "tp-start: 777.777, foo, 0\n"
 564         "tp-end:\n"
 565         "tp-start: 777.777, foo, 0\n"
 566         "tp-end: 777\n"
 567         "tp-start: 777.777, foo, 0\n"
 568         "tp-end: 777.\n"
 569         "tp-start: 777.777, foo, 0\n"
 570         "tp-end: 777.888\n"
 571         "tp-start: 777.777, foo, 0\n"
 572         "tp-end: 777.888, \n"
 573         "tp-start: 777.777, foo, 0\n"
 574         "tp-end: 777.888, bar\n"
 575         "tp-start: 777.777, foo, 0\n"
 576         "tp-end: 777.888, foo,\n"
 577     ;
 578
 579     const char* exp_calls[] = {
 580         "got_ntps(1)",
 581         NULL
 582     };
 583
 584     const char* exp_errors[] = {
 585         "4: Unexpected token `foo'; expected start of test program",
 586         "5: Unexpected token `<<NEWLINE>>'; expected `:'",
 587         "6: Unexpected token `<<NEWLINE>>'; expected timestamp",
 588         "7: Malformed timestamp value 123",
 589         "8: Malformed timestamp value 123.",
 590         "9: Unexpected token `<<NEWLINE>>'; expected `,'",
 591         "10: Unexpected token `<<NEWLINE>>'; expected test program name",
 592         "11: Unexpected token `<<NEWLINE>>'; expected `,'",
 593         "12: Unexpected token `<<NEWLINE>>'; expected number of test programs",
 594         "14: Unexpected token `bar'; expected end of test program",
 595         "16: Unexpected token `<<NEWLINE>>'; expected `:'",
 596         "18: Unexpected token `<<NEWLINE>>'; expected timestamp",
 597         "20: Malformed timestamp value 777",
 598         "22: Malformed timestamp value 777.",
 599         "24: Unexpected token `<<NEWLINE>>'; expected `,'",
 600
 601         "26: Unexpected token `<<NEWLINE>>'; expected test program name",
 602         "28: Test program name used in terminator does not match opening",
 603         "30: Empty reason for failed test program",
 604         NULL
 605     };
 606
 607     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 608 }
 609
 610 ATF_TEST_CASE_WITHOUT_HEAD(tps_55);
 611 ATF_TEST_CASE_BODY(tps_55)
 612 {
 613     const char* input =
 614         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 615         "\n"
 616         "tps-count: 1\n"
 617         "tp-start: 100.200, foo, 1\n"
 618         "foo\n"
 619         "tc-start\n"
 620         "tc-start:\n"
 621         "tc-start: 111\n"
 622         "tc-start: 111.\n"
 623         "tc-start: 111.222\n"
 624         "tc-start: 111.222,\n"
 625         "tc-start: 111.222, foo\n"
 626         "bar\n"
 627         "tc-start: 111.333, foo\n"
 628         "tc-end\n"
 629         "tc-start: 111.444, foo\n"
 630         "tc-end:\n"
 631         "tc-start: 111.444, foo\n"
 632         "tc-end: 111\n"
 633         "tc-start: 111.444, foo\n"
 634         "tc-end: 111.\n"
 635         "tc-start: 111.444, foo\n"
 636         "tc-end: 111.555\n"
 637         "tc-start: 111.444, foo\n"
 638         "tc-end: 111.555, \n"
 639         "tc-start: 111.444, foo\n"
 640         "tc-end: 111.555, bar\n"
 641         "tc-start: 111.444, foo\n"
 642         "tc-end: 111.555, foo\n"
 643         "tc-start: 111.444, foo\n"
 644         "tc-end: 111.555, foo,\n"
 645         "tp-end: 111.666, foo\n"
 646     ;
 647
 648     const char* exp_calls[] = {
 649         "got_ntps(1)",
 650         "got_tp_start(foo, 1)",
 651         NULL
 652     };
 653
 654     // NO_CHECK_STYLE_BEGIN
 655     const char* exp_errors[] = {
 656         "5: Unexpected token `foo'; expected start of test case",
 657         "6: Unexpected token `<<NEWLINE>>'; expected `:'",
 658         "7: Unexpected token `<<NEWLINE>>'; expected timestamp",
 659         "8: Malformed timestamp value 111",
 660         "9: Malformed timestamp value 111.",
 661         "10: Unexpected token `<<NEWLINE>>'; expected `,'",
 662         "11: Unexpected token `<<NEWLINE>>'; expected test case name",
 663         "13: Unexpected token `bar'; expected end of test case or test case's stdout/stderr line",
 664         "15: Unexpected token `<<NEWLINE>>'; expected `:'",
 665         "17: Unexpected token `<<NEWLINE>>'; expected timestamp",
 666         "19: Malformed timestamp value 111",
 667         "21: Malformed timestamp value 111.",
 668         "23: Unexpected token `<<NEWLINE>>'; expected `,'",
 669         "25: Unexpected token `<<NEWLINE>>'; expected test case name",
 670         "27: Test case name used in terminator does not match opening",
 671         "29: Unexpected token `<<NEWLINE>>'; expected `,'",
 672         "31: Unexpected token `<<NEWLINE>>'; expected expected_{death,exit,failure,signal,timeout}, failed, passed or skipped",
 673         "32: Unexpected token `tp-end'; expected start of test case",
 674         NULL
 675     };
 676     // NO_CHECK_STYLE_END
 677
 678     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 679 }
 680
 681 ATF_TEST_CASE_WITHOUT_HEAD(tps_56);
 682 ATF_TEST_CASE_BODY(tps_56)
 683 {
 684     const char* input =
 685         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 686         "\n"
 687         "tps-count: 1\n"
 688         "tp-start: 111.222, foo, 1\n"
 689         "tc-start: 111.333, foo\n"
 690         "tc-end: 111.444, foo, passe\n"
 691         "tc-start: 111.333, foo\n"
 692         "tc-end: 111.444, foo, passed,\n"
 693         "tc-start: 111.555, bar\n"
 694         "tc-end: 111.666, bar, failed\n"
 695         "tc-start: 111.555, bar\n"
 696         "tc-end: 111.666, bar, failed,\n"
 697         "tc-start: 111.555, baz\n"
 698         "tc-end: 111.666, baz, skipped\n"
 699         "tc-start: 111.555, baz\n"
 700         "tc-end: 111.666, baz, skipped,\n"
 701         "tp-end: 111.777, foo\n"
 702     ;
 703
 704     const char* exp_calls[] = {
 705         "got_ntps(1)",
 706         "got_tp_start(foo, 1)",
 707         "got_tc_start(foo)",
 708         NULL
 709     };
 710
 711     // NO_CHECK_STYLE_BEGIN
 712     const char* exp_errors[] = {
 713         "6: Unexpected token `passe'; expected expected_{death,exit,failure,signal,timeout}, failed, passed or skipped",
 714         "8: Unexpected token `,'; expected new line",
 715         "10: Unexpected token `<<NEWLINE>>'; expected `,'",
 716         "12: Empty reason for failed test case result",
 717         "14: Unexpected token `<<NEWLINE>>'; expected `,'",
 718         "16: Empty reason for skipped test case result",
 719         "17: Unexpected token `tp-end'; expected start of test case",
 720         NULL
 721     };
 722     // NO_CHECK_STYLE_END
 723
 724     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 725 }
 726
 727 ATF_TEST_CASE_WITHOUT_HEAD(tps_57);
 728 ATF_TEST_CASE_BODY(tps_57)
 729 {
 730     const char* input =
 731         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 732         "\n"
 733         "tps-count: 2\n"
 734         "tp-start: 111.222, foo, 0\n"
 735         "tp-end: 111.333, foo\n"
 736     ;
 737
 738     const char* exp_calls[] = {
 739         "got_ntps(2)",
 740         "got_tp_start(foo, 0)",
 741         "got_tp_end()",
 742         NULL
 743     };
 744
 745     const char* exp_errors[] = {
 746         "6: Unexpected token `<<EOF>>'; expected start of test program",
 747         NULL
 748     };
 749
 750     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 751 }
 752
 753 ATF_TEST_CASE_WITHOUT_HEAD(tps_58);
 754 ATF_TEST_CASE_BODY(tps_58)
 755 {
 756     const char* input =
 757         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 758         "\n"
 759         "tps-count: 1\n"
 760         "tp-start: 111.222, foo, 0\n"
 761         "tp-end: 111.333, foo\n"
 762         "tp-start: 111.444, bar, 0\n"
 763         "tp-end: 111.555, bar\n"
 764     ;
 765
 766     const char* exp_calls[] = {
 767         "got_ntps(1)",
 768         "got_tp_start(foo, 0)",
 769         "got_tp_end()",
 770         NULL
 771     };
 772
 773     const char* exp_errors[] = {
 774         "6: Unexpected token `tp-start'; expected end of stream or info field",
 775         NULL
 776     };
 777
 778     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 779 }
 780
 781 ATF_TEST_CASE_WITHOUT_HEAD(tps_59);
 782 ATF_TEST_CASE_BODY(tps_59)
 783 {
 784     const char* input =
 785         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 786         "\n"
 787         "info\n"
 788     ;
 789
 790     const char* exp_calls[] = {
 791         NULL
 792     };
 793
 794     const char* exp_errors[] = {
 795         "3: Unexpected token `<<NEWLINE>>'; expected `:'",
 796         NULL
 797     };
 798
 799     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 800 }
 801
 802 ATF_TEST_CASE_WITHOUT_HEAD(tps_60);
 803 ATF_TEST_CASE_BODY(tps_60)
 804 {
 805     const char* input =
 806         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 807         "\n"
 808         "info:\n"
 809     ;
 810
 811     const char* exp_calls[] = {
 812         NULL
 813     };
 814
 815     const char* exp_errors[] = {
 816         "3: Unexpected token `<<NEWLINE>>'; expected info property name",
 817         NULL
 818     };
 819
 820     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 821 }
 822
 823 ATF_TEST_CASE_WITHOUT_HEAD(tps_61);
 824 ATF_TEST_CASE_BODY(tps_61)
 825 {
 826     const char* input =
 827         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 828         "\n"
 829         "info: a\n"
 830     ;
 831
 832     const char* exp_calls[] = {
 833         NULL
 834     };
 835
 836     const char* exp_errors[] = {
 837         "3: Unexpected token `<<NEWLINE>>'; expected `,'",
 838         NULL
 839     };
 840
 841     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 842 }
 843
 844 ATF_TEST_CASE_WITHOUT_HEAD(tps_62);
 845 ATF_TEST_CASE_BODY(tps_62)
 846 {
 847     const char* input =
 848         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 849         "\n"
 850         "info: a,\n"
 851     ;
 852
 853     const char* exp_calls[] = {
 854         "got_info(a, )",
 855         NULL
 856     };
 857
 858     const char* exp_errors[] = {
 859         "4: Unexpected token `<<EOF>>'; expected tps-count or info field",
 860         NULL
 861     };
 862
 863     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 864 }
 865
 866 ATF_TEST_CASE_WITHOUT_HEAD(tps_63);
 867 ATF_TEST_CASE_BODY(tps_63)
 868 {
 869     const char* input =
 870         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 871         "\n"
 872         "info: a, b\n"
 873     ;
 874
 875     const char* exp_calls[] = {
 876         "got_info(a, b)",
 877         NULL
 878     };
 879
 880     const char* exp_errors[] = {
 881         "4: Unexpected token `<<EOF>>'; expected tps-count or info field",
 882         NULL
 883     };
 884
 885     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 886 }
 887
 888 ATF_TEST_CASE_WITHOUT_HEAD(tps_64);
 889 ATF_TEST_CASE_BODY(tps_64)
 890 {
 891     const char* input =
 892         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 893         "\n"
 894         "info: a, b\n"
 895         "info: a.b.c.def, g\n"
 896         "tps-count\n"
 897     ;
 898
 899     const char* exp_calls[] = {
 900         "got_info(a, b)",
 901         "got_info(a.b.c.def, g)",
 902         NULL
 903     };
 904
 905     const char* exp_errors[] = {
 906         "5: Unexpected token `<<NEWLINE>>'; expected `:'",
 907         NULL
 908     };
 909
 910     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 911 }
 912
 913 ATF_TEST_CASE_WITHOUT_HEAD(tps_65);
 914 ATF_TEST_CASE_BODY(tps_65)
 915 {
 916     const char* input =
 917         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 918         "\n"
 919         "info: a, b\n"
 920         "tps-count:\n"
 921     ;
 922
 923     const char* exp_calls[] = {
 924         "got_info(a, b)",
 925         NULL
 926     };
 927
 928     const char* exp_errors[] = {
 929         "4: Unexpected token `<<NEWLINE>>'; expected number of test programs",
 930         NULL
 931     };
 932
 933     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 934 }
 935
 936 ATF_TEST_CASE_WITHOUT_HEAD(tps_66);
 937 ATF_TEST_CASE_BODY(tps_66)
 938 {
 939     const char* input =
 940         "Content-Type: application/X-atf-tps; version=\"3\"\n"
 941         "\n"
 942         "info: a, b\n"
 943         "tps-count: 0\n"
 944         "info\n"
 945     ;
 946
 947     const char* exp_calls[] = {
 948         "got_info(a, b)",
 949         "got_ntps(0)",
 950         NULL
 951     };
 952
 953     const char* exp_errors[] = {
 954         "5: Unexpected token `<<NEWLINE>>'; expected `:'",
 955         NULL
 956     };
 957
 958     do_parser_test< tps_reader >(input, exp_calls, exp_errors);
 959 }
 960
 961 ATF_INIT_TEST_CASES(tcs)
 962 {
 963     ATF_ADD_TEST_CASE(tcs, tps_1);
 964     ATF_ADD_TEST_CASE(tcs, tps_2);
 965     ATF_ADD_TEST_CASE(tcs, tps_3);
 966     ATF_ADD_TEST_CASE(tcs, tps_4);
 967     ATF_ADD_TEST_CASE(tcs, tps_5);
 968     ATF_ADD_TEST_CASE(tcs, tps_6);
 969     ATF_ADD_TEST_CASE(tcs, tps_50);
 970     ATF_ADD_TEST_CASE(tcs, tps_51);
 971     ATF_ADD_TEST_CASE(tcs, tps_52);
 972     ATF_ADD_TEST_CASE(tcs, tps_53);
 973     ATF_ADD_TEST_CASE(tcs, tps_54);
 974     ATF_ADD_TEST_CASE(tcs, tps_55);
 975     ATF_ADD_TEST_CASE(tcs, tps_56);
 976     ATF_ADD_TEST_CASE(tcs, tps_57);
 977     ATF_ADD_TEST_CASE(tcs, tps_58);
 978     ATF_ADD_TEST_CASE(tcs, tps_59);
 979     ATF_ADD_TEST_CASE(tcs, tps_60);
 980     ATF_ADD_TEST_CASE(tcs, tps_61);
 981     ATF_ADD_TEST_CASE(tcs, tps_62);
 982     ATF_ADD_TEST_CASE(tcs, tps_63);
 983     ATF_ADD_TEST_CASE(tcs, tps_64);
 984     ATF_ADD_TEST_CASE(tcs, tps_65);
 985     ATF_ADD_TEST_CASE(tcs, tps_66);
 986 }
 987