1240116Smarcel// 2240116Smarcel// Automated Testing Framework (atf) 3240116Smarcel// 4240116Smarcel// Copyright (c) 2010 The NetBSD Foundation, Inc. 5240116Smarcel// All rights reserved. 6240116Smarcel// 7240116Smarcel// Redistribution and use in source and binary forms, with or without 8240116Smarcel// modification, are permitted provided that the following conditions 9240116Smarcel// are met: 10240116Smarcel// 1. Redistributions of source code must retain the above copyright 11240116Smarcel// notice, this list of conditions and the following disclaimer. 12240116Smarcel// 2. Redistributions in binary form must reproduce the above copyright 13240116Smarcel// notice, this list of conditions and the following disclaimer in the 14240116Smarcel// documentation and/or other materials provided with the distribution. 15240116Smarcel// 16240116Smarcel// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17240116Smarcel// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18240116Smarcel// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19240116Smarcel// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20240116Smarcel// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21240116Smarcel// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22240116Smarcel// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23240116Smarcel// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24240116Smarcel// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25240116Smarcel// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26240116Smarcel// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27240116Smarcel// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28240116Smarcel// 29240116Smarcel 30240116Smarcel#include <fstream> 31240116Smarcel#include <iostream> 32240116Smarcel 33240116Smarcel#include "atf-c++/macros.hpp" 34240116Smarcel 35240116Smarcel#include "atf-c++/detail/parser.hpp" 36240116Smarcel#include "atf-c++/detail/test_helpers.hpp" 37240116Smarcel#include "atf-c++/detail/text.hpp" 38240116Smarcel 39240116Smarcel#include "test-program.hpp" 40240116Smarcel 41240116Smarcelnamespace impl = atf::atf_run; 42240116Smarcelnamespace detail = atf::atf_run::detail; 43240116Smarcel 44240116Smarcelusing atf::tests::vars_map; 45240116Smarcel 46240116Smarcel// ------------------------------------------------------------------------- 47240116Smarcel// Auxiliary functions. 48240116Smarcel// ------------------------------------------------------------------------- 49240116Smarcel 50240116Smarcelstatic 51240116Smarcelatf::fs::path 52240116Smarcelget_helper(const atf::tests::tc& tc, const char* name) 53240116Smarcel{ 54240116Smarcel return atf::fs::path(tc.get_config_var("srcdir")) / name; 55240116Smarcel} 56240116Smarcel 57240116Smarcelstatic 58240116Smarcelvoid 59240116Smarcelcheck_property(const vars_map& props, const char* name, const char* value) 60240116Smarcel{ 61240116Smarcel const vars_map::const_iterator iter = props.find(name); 62240116Smarcel ATF_REQUIRE(iter != props.end()); 63240116Smarcel ATF_REQUIRE_EQ(value, (*iter).second); 64240116Smarcel} 65240116Smarcel 66240116Smarcelstatic void 67240116Smarcelcheck_result(const char* exp_state, const int exp_value, const char* exp_reason, 68240116Smarcel const impl::test_case_result& tcr) 69240116Smarcel{ 70240116Smarcel ATF_REQUIRE_EQ(exp_state, tcr.state()); 71240116Smarcel ATF_REQUIRE_EQ(exp_value, tcr.value()); 72240116Smarcel ATF_REQUIRE_EQ(exp_reason, tcr.reason()); 73240116Smarcel} 74240116Smarcel 75240116Smarcelstatic 76240116Smarcelvoid 77240116Smarcelwrite_test_case_result(const char *results_path, const std::string& contents) 78240116Smarcel{ 79240116Smarcel std::ofstream results_file(results_path); 80240116Smarcel ATF_REQUIRE(results_file); 81240116Smarcel 82240116Smarcel results_file << contents; 83240116Smarcel} 84240116Smarcel 85240116Smarcelstatic 86240116Smarcelvoid 87240116Smarcelprint_indented(const std::string& str) 88240116Smarcel{ 89240116Smarcel std::vector< std::string > ws = atf::text::split(str, "\n"); 90240116Smarcel for (std::vector< std::string >::const_iterator iter = ws.begin(); 91240116Smarcel iter != ws.end(); iter++) 92240116Smarcel std::cout << ">>" << *iter << "<<\n"; 93240116Smarcel} 94240116Smarcel 95240116Smarcel// XXX Should this string handling and verbosity level be part of the 96240116Smarcel// ATF_REQUIRE_EQ macro? It may be hard to predict sometimes that a 97240116Smarcel// string can have newlines in it, and so the error message generated 98240116Smarcel// at the moment will be bogus if there are some. 99240116Smarcelstatic 100240116Smarcelvoid 101240116Smarcelcheck_match(const atf::tests::tc& tc, const std::string& str, 102240116Smarcel const std::string& exp) 103240116Smarcel{ 104240116Smarcel if (!atf::text::match(str, exp)) { 105240116Smarcel std::cout << "String match check failed.\n" 106240116Smarcel << "Adding >> and << to delimit the string boundaries " 107240116Smarcel "below.\n"; 108240116Smarcel std::cout << "GOT:\n"; 109240116Smarcel print_indented(str); 110240116Smarcel std::cout << "EXPECTED:\n"; 111240116Smarcel print_indented(exp); 112240116Smarcel tc.fail("Constructed string differs from the expected one"); 113240116Smarcel } 114240116Smarcel} 115240116Smarcel 116240116Smarcel// ------------------------------------------------------------------------- 117240116Smarcel// Tests for the "tp" reader. 118240116Smarcel// ------------------------------------------------------------------------- 119240116Smarcel 120240116Smarcelclass tp_reader : protected detail::atf_tp_reader { 121240116Smarcel void 122240116Smarcel got_tc(const std::string& ident, 123240116Smarcel const std::map< std::string, std::string >& md) 124240116Smarcel { 125240116Smarcel std::string call = "got_tc(" + ident + ", {"; 126240116Smarcel for (std::map< std::string, std::string >::const_iterator iter = 127240116Smarcel md.begin(); iter != md.end(); iter++) { 128240116Smarcel if (iter != md.begin()) 129240116Smarcel call += ", "; 130240116Smarcel call += (*iter).first + '=' + (*iter).second; 131240116Smarcel } 132240116Smarcel call += "})"; 133240116Smarcel m_calls.push_back(call); 134240116Smarcel } 135240116Smarcel 136240116Smarcel void 137240116Smarcel got_eof(void) 138240116Smarcel { 139240116Smarcel m_calls.push_back("got_eof()"); 140240116Smarcel } 141240116Smarcel 142240116Smarcelpublic: 143240116Smarcel tp_reader(std::istream& is) : 144240116Smarcel detail::atf_tp_reader(is) 145240116Smarcel { 146240116Smarcel } 147240116Smarcel 148240116Smarcel void 149240116Smarcel read(void) 150240116Smarcel { 151240116Smarcel atf_tp_reader::read(); 152240116Smarcel } 153240116Smarcel 154240116Smarcel std::vector< std::string > m_calls; 155240116Smarcel}; 156240116Smarcel 157240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_1); 158240116SmarcelATF_TEST_CASE_BODY(tp_1) 159240116Smarcel{ 160240116Smarcel const char* input = 161240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 162240116Smarcel "\n" 163240116Smarcel "ident: test_case_1\n" 164240116Smarcel "\n" 165240116Smarcel "ident: test_case_2\n" 166240116Smarcel "\n" 167240116Smarcel "ident: test_case_3\n" 168240116Smarcel ; 169240116Smarcel 170240116Smarcel const char* exp_calls[] = { 171240116Smarcel "got_tc(test_case_1, {ident=test_case_1})", 172240116Smarcel "got_tc(test_case_2, {ident=test_case_2})", 173240116Smarcel "got_tc(test_case_3, {ident=test_case_3})", 174240116Smarcel "got_eof()", 175240116Smarcel NULL 176240116Smarcel }; 177240116Smarcel 178240116Smarcel const char* exp_errors[] = { 179240116Smarcel NULL 180240116Smarcel }; 181240116Smarcel 182240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 183240116Smarcel} 184240116Smarcel 185240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_2); 186240116SmarcelATF_TEST_CASE_BODY(tp_2) 187240116Smarcel{ 188240116Smarcel const char* input = 189240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 190240116Smarcel "\n" 191240116Smarcel "ident: test_case_1\n" 192240116Smarcel "descr: This is the description\n" 193240116Smarcel "timeout: 300\n" 194240116Smarcel "\n" 195240116Smarcel "ident: test_case_2\n" 196240116Smarcel "\n" 197240116Smarcel "ident: test_case_3\n" 198240116Smarcel "X-prop1: A custom property\n" 199240116Smarcel "descr: Third test case\n" 200240116Smarcel ; 201240116Smarcel 202240116Smarcel // NO_CHECK_STYLE_BEGIN 203240116Smarcel const char* exp_calls[] = { 204240116Smarcel "got_tc(test_case_1, {descr=This is the description, ident=test_case_1, timeout=300})", 205240116Smarcel "got_tc(test_case_2, {ident=test_case_2})", 206240116Smarcel "got_tc(test_case_3, {X-prop1=A custom property, descr=Third test case, ident=test_case_3})", 207240116Smarcel "got_eof()", 208240116Smarcel NULL 209240116Smarcel }; 210240116Smarcel // NO_CHECK_STYLE_END 211240116Smarcel 212240116Smarcel const char* exp_errors[] = { 213240116Smarcel NULL 214240116Smarcel }; 215240116Smarcel 216240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 217240116Smarcel} 218240116Smarcel 219240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_3); 220240116SmarcelATF_TEST_CASE_BODY(tp_3) 221240116Smarcel{ 222240116Smarcel const char* input = 223240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 224240116Smarcel "\n" 225240116Smarcel "ident: single_test\n" 226240116Smarcel "descr: Some description\n" 227240116Smarcel "timeout: 300\n" 228240116Smarcel "require.arch: thearch\n" 229240116Smarcel "require.config: foo-bar\n" 230240116Smarcel "require.files: /a/1 /b/2\n" 231240116Smarcel "require.machine: themachine\n" 232240116Smarcel "require.progs: /bin/cp mv\n" 233240116Smarcel "require.user: root\n" 234240116Smarcel ; 235240116Smarcel 236240116Smarcel // NO_CHECK_STYLE_BEGIN 237240116Smarcel const char* exp_calls[] = { 238240116Smarcel "got_tc(single_test, {descr=Some description, ident=single_test, require.arch=thearch, require.config=foo-bar, require.files=/a/1 /b/2, require.machine=themachine, require.progs=/bin/cp mv, require.user=root, timeout=300})", 239240116Smarcel "got_eof()", 240240116Smarcel NULL 241240116Smarcel }; 242240116Smarcel // NO_CHECK_STYLE_END 243240116Smarcel 244240116Smarcel const char* exp_errors[] = { 245240116Smarcel NULL 246240116Smarcel }; 247240116Smarcel 248240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 249240116Smarcel} 250240116Smarcel 251240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_4); 252240116SmarcelATF_TEST_CASE_BODY(tp_4) 253240116Smarcel{ 254240116Smarcel const char* input = 255240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 256240116Smarcel "\n" 257240116Smarcel "ident: single_test \n" 258240116Smarcel "descr: Some description \n" 259240116Smarcel ; 260240116Smarcel 261240116Smarcel const char* exp_calls[] = { 262240116Smarcel "got_tc(single_test, {descr=Some description, ident=single_test})", 263240116Smarcel "got_eof()", 264240116Smarcel NULL 265240116Smarcel }; 266240116Smarcel 267240116Smarcel const char* exp_errors[] = { 268240116Smarcel NULL 269240116Smarcel }; 270240116Smarcel 271240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 272240116Smarcel} 273240116Smarcel 274240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_50); 275240116SmarcelATF_TEST_CASE_BODY(tp_50) 276240116Smarcel{ 277240116Smarcel const char* input = 278240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 279240116Smarcel "\n" 280240116Smarcel ; 281240116Smarcel 282240116Smarcel const char* exp_calls[] = { 283240116Smarcel NULL 284240116Smarcel }; 285240116Smarcel 286240116Smarcel const char* exp_errors[] = { 287240116Smarcel "3: Unexpected token `<<EOF>>'; expected property name", 288240116Smarcel NULL 289240116Smarcel }; 290240116Smarcel 291240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 292240116Smarcel} 293240116Smarcel 294240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_51); 295240116SmarcelATF_TEST_CASE_BODY(tp_51) 296240116Smarcel{ 297240116Smarcel const char* input = 298240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 299240116Smarcel "\n" 300240116Smarcel "\n" 301240116Smarcel "\n" 302240116Smarcel "\n" 303240116Smarcel ; 304240116Smarcel 305240116Smarcel const char* exp_calls[] = { 306240116Smarcel NULL 307240116Smarcel }; 308240116Smarcel 309240116Smarcel const char* exp_errors[] = { 310240116Smarcel "3: Unexpected token `<<NEWLINE>>'; expected property name", 311240116Smarcel NULL 312240116Smarcel }; 313240116Smarcel 314240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 315240116Smarcel} 316240116Smarcel 317240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_52); 318240116SmarcelATF_TEST_CASE_BODY(tp_52) 319240116Smarcel{ 320240116Smarcel const char* input = 321240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 322240116Smarcel "\n" 323240116Smarcel "ident: test1\n" 324240116Smarcel "ident: test2\n" 325240116Smarcel ; 326240116Smarcel 327240116Smarcel const char* exp_calls[] = { 328240116Smarcel "got_tc(test1, {ident=test1})", 329240116Smarcel "got_eof()", 330240116Smarcel NULL 331240116Smarcel }; 332240116Smarcel 333240116Smarcel const char* exp_errors[] = { 334240116Smarcel NULL 335240116Smarcel }; 336240116Smarcel 337240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 338240116Smarcel} 339240116Smarcel 340240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_53); 341240116SmarcelATF_TEST_CASE_BODY(tp_53) 342240116Smarcel{ 343240116Smarcel const char* input = 344240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 345240116Smarcel "\n" 346240116Smarcel "descr: Out of order\n" 347240116Smarcel "ident: test1\n" 348240116Smarcel ; 349240116Smarcel 350240116Smarcel const char* exp_calls[] = { 351240116Smarcel NULL 352240116Smarcel }; 353240116Smarcel 354240116Smarcel const char* exp_errors[] = { 355240116Smarcel "3: First property of a test case must be 'ident'", 356240116Smarcel NULL 357240116Smarcel }; 358240116Smarcel 359240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 360240116Smarcel} 361240116Smarcel 362240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_54); 363240116SmarcelATF_TEST_CASE_BODY(tp_54) 364240116Smarcel{ 365240116Smarcel const char* input = 366240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 367240116Smarcel "\n" 368240116Smarcel "ident:\n" 369240116Smarcel ; 370240116Smarcel 371240116Smarcel const char* exp_calls[] = { 372240116Smarcel NULL 373240116Smarcel }; 374240116Smarcel 375240116Smarcel const char* exp_errors[] = { 376240116Smarcel "3: The value for 'ident' cannot be empty", 377240116Smarcel NULL 378240116Smarcel }; 379240116Smarcel 380240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 381240116Smarcel} 382240116Smarcel 383240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_55); 384240116SmarcelATF_TEST_CASE_BODY(tp_55) 385240116Smarcel{ 386240116Smarcel const char* input = 387240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 388240116Smarcel "\n" 389240116Smarcel "ident: +*,\n" 390240116Smarcel ; 391240116Smarcel 392240116Smarcel const char* exp_calls[] = { 393240116Smarcel NULL 394240116Smarcel }; 395240116Smarcel 396240116Smarcel const char* exp_errors[] = { 397240116Smarcel "3: The identifier must match ^[_A-Za-z0-9]+$; was '+*,'", 398240116Smarcel NULL 399240116Smarcel }; 400240116Smarcel 401240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 402240116Smarcel} 403240116Smarcel 404240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_56); 405240116SmarcelATF_TEST_CASE_BODY(tp_56) 406240116Smarcel{ 407240116Smarcel const char* input = 408240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 409240116Smarcel "\n" 410240116Smarcel "ident: test\n" 411240116Smarcel "timeout: hello\n" 412240116Smarcel ; 413240116Smarcel 414240116Smarcel const char* exp_calls[] = { 415240116Smarcel NULL 416240116Smarcel }; 417240116Smarcel 418240116Smarcel const char* exp_errors[] = { 419240116Smarcel "4: The timeout property requires an integer value", 420240116Smarcel NULL 421240116Smarcel }; 422240116Smarcel 423240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 424240116Smarcel} 425240116Smarcel 426240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_57); 427240116SmarcelATF_TEST_CASE_BODY(tp_57) 428240116Smarcel{ 429240116Smarcel const char* input = 430240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 431240116Smarcel "\n" 432240116Smarcel "ident: test\n" 433240116Smarcel "unknown: property\n" 434240116Smarcel ; 435240116Smarcel 436240116Smarcel const char* exp_calls[] = { 437240116Smarcel NULL 438240116Smarcel }; 439240116Smarcel 440240116Smarcel const char* exp_errors[] = { 441240116Smarcel "4: Unknown property 'unknown'", 442240116Smarcel NULL 443240116Smarcel }; 444240116Smarcel 445240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 446240116Smarcel} 447240116Smarcel 448240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_58); 449240116SmarcelATF_TEST_CASE_BODY(tp_58) 450240116Smarcel{ 451240116Smarcel const char* input = 452240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 453240116Smarcel "\n" 454240116Smarcel "ident: test\n" 455240116Smarcel "X-foo:\n" 456240116Smarcel ; 457240116Smarcel 458240116Smarcel const char* exp_calls[] = { 459240116Smarcel NULL 460240116Smarcel }; 461240116Smarcel 462240116Smarcel const char* exp_errors[] = { 463240116Smarcel "4: The value for 'X-foo' cannot be empty", 464240116Smarcel NULL 465240116Smarcel }; 466240116Smarcel 467240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 468240116Smarcel} 469240116Smarcel 470240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_59); 471240116SmarcelATF_TEST_CASE_BODY(tp_59) 472240116Smarcel{ 473240116Smarcel const char* input = 474240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 475240116Smarcel "\n" 476240116Smarcel "\n" 477240116Smarcel "ident: test\n" 478240116Smarcel "timeout: 300\n" 479240116Smarcel ; 480240116Smarcel 481240116Smarcel const char* exp_calls[] = { 482240116Smarcel NULL 483240116Smarcel }; 484240116Smarcel 485240116Smarcel const char* exp_errors[] = { 486240116Smarcel "3: Unexpected token `<<NEWLINE>>'; expected property name", 487240116Smarcel NULL 488240116Smarcel }; 489240116Smarcel 490240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 491240116Smarcel} 492240116Smarcel 493240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(tp_60); 494240116SmarcelATF_TEST_CASE_BODY(tp_60) 495240116Smarcel{ 496240116Smarcel const char* input = 497240116Smarcel "Content-Type: application/X-atf-tp; version=\"1\"\n" 498240116Smarcel "\n" 499240116Smarcel "ident: test\n" 500240116Smarcel "require.memory: 12345D\n" 501240116Smarcel ; 502240116Smarcel 503240116Smarcel const char* exp_calls[] = { 504240116Smarcel NULL 505240116Smarcel }; 506240116Smarcel 507240116Smarcel const char* exp_errors[] = { 508240116Smarcel "4: The require.memory property requires an integer value representing" 509240116Smarcel " an amount of bytes", 510240116Smarcel NULL 511240116Smarcel }; 512240116Smarcel 513240116Smarcel do_parser_test< tp_reader >(input, exp_calls, exp_errors); 514240116Smarcel} 515240116Smarcel 516240116Smarcel// ------------------------------------------------------------------------- 517240116Smarcel// Tests for the "tps" writer. 518240116Smarcel// ------------------------------------------------------------------------- 519240116Smarcel 520240116SmarcelATF_TEST_CASE(atf_tps_writer); 521240116SmarcelATF_TEST_CASE_HEAD(atf_tps_writer) 522240116Smarcel{ 523240116Smarcel set_md_var("descr", "Verifies the application/X-atf-tps writer"); 524240116Smarcel} 525240116SmarcelATF_TEST_CASE_BODY(atf_tps_writer) 526240116Smarcel{ 527240116Smarcel std::ostringstream expss; 528240116Smarcel std::ostringstream ss; 529240116Smarcel const char *ts_regex = "[0-9]+\\.[0-9]{1,6}, "; 530240116Smarcel 531240116Smarcel#define RESET \ 532240116Smarcel expss.str(""); \ 533240116Smarcel ss.str("") 534240116Smarcel 535240116Smarcel#define CHECK \ 536240116Smarcel check_match(*this, ss.str(), expss.str()) 537240116Smarcel 538240116Smarcel { 539240116Smarcel RESET; 540240116Smarcel 541240116Smarcel impl::atf_tps_writer w(ss); 542240116Smarcel expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 543240116Smarcel CHECK; 544240116Smarcel } 545240116Smarcel 546240116Smarcel { 547240116Smarcel RESET; 548240116Smarcel 549240116Smarcel impl::atf_tps_writer w(ss); 550240116Smarcel expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 551240116Smarcel CHECK; 552240116Smarcel 553240116Smarcel w.info("foo", "bar"); 554240116Smarcel expss << "info: foo, bar\n"; 555240116Smarcel CHECK; 556240116Smarcel 557240116Smarcel w.info("baz", "second info"); 558240116Smarcel expss << "info: baz, second info\n"; 559240116Smarcel CHECK; 560240116Smarcel } 561240116Smarcel 562240116Smarcel { 563240116Smarcel RESET; 564240116Smarcel 565240116Smarcel impl::atf_tps_writer w(ss); 566240116Smarcel expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 567240116Smarcel CHECK; 568240116Smarcel 569240116Smarcel w.ntps(0); 570240116Smarcel expss << "tps-count: 0\n"; 571240116Smarcel CHECK; 572240116Smarcel } 573240116Smarcel 574240116Smarcel { 575240116Smarcel RESET; 576240116Smarcel 577240116Smarcel impl::atf_tps_writer w(ss); 578240116Smarcel expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 579240116Smarcel CHECK; 580240116Smarcel 581240116Smarcel w.ntps(123); 582240116Smarcel expss << "tps-count: 123\n"; 583240116Smarcel CHECK; 584240116Smarcel } 585240116Smarcel 586240116Smarcel { 587240116Smarcel RESET; 588240116Smarcel 589240116Smarcel impl::atf_tps_writer w(ss); 590240116Smarcel expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 591240116Smarcel CHECK; 592240116Smarcel 593240116Smarcel w.ntps(2); 594240116Smarcel expss << "tps-count: 2\n"; 595240116Smarcel CHECK; 596240116Smarcel 597240116Smarcel w.start_tp("foo", 0); 598240116Smarcel expss << "tp-start: " << ts_regex << "foo, 0\n"; 599240116Smarcel CHECK; 600240116Smarcel 601240116Smarcel w.end_tp(""); 602240116Smarcel expss << "tp-end: " << ts_regex << "foo\n"; 603240116Smarcel CHECK; 604240116Smarcel 605240116Smarcel w.start_tp("bar", 0); 606240116Smarcel expss << "tp-start: " << ts_regex << "bar, 0\n"; 607240116Smarcel CHECK; 608240116Smarcel 609240116Smarcel w.end_tp("failed program"); 610240116Smarcel expss << "tp-end: " << ts_regex << "bar, failed program\n"; 611240116Smarcel CHECK; 612240116Smarcel } 613240116Smarcel 614240116Smarcel { 615240116Smarcel RESET; 616240116Smarcel 617240116Smarcel impl::atf_tps_writer w(ss); 618240116Smarcel expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 619240116Smarcel CHECK; 620240116Smarcel 621240116Smarcel w.ntps(1); 622240116Smarcel expss << "tps-count: 1\n"; 623240116Smarcel CHECK; 624240116Smarcel 625240116Smarcel w.start_tp("foo", 1); 626240116Smarcel expss << "tp-start: " << ts_regex << "foo, 1\n"; 627240116Smarcel CHECK; 628240116Smarcel 629240116Smarcel w.start_tc("brokentc"); 630240116Smarcel expss << "tc-start: " << ts_regex << "brokentc\n"; 631240116Smarcel CHECK; 632240116Smarcel 633240116Smarcel w.end_tp("aborted"); 634240116Smarcel expss << "tp-end: " << ts_regex << "foo, aborted\n"; 635240116Smarcel CHECK; 636240116Smarcel } 637240116Smarcel 638240116Smarcel { 639240116Smarcel RESET; 640240116Smarcel 641240116Smarcel impl::atf_tps_writer w(ss); 642240116Smarcel expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 643240116Smarcel CHECK; 644240116Smarcel 645240116Smarcel w.ntps(1); 646240116Smarcel expss << "tps-count: 1\n"; 647240116Smarcel CHECK; 648240116Smarcel 649240116Smarcel w.start_tp("thetp", 3); 650240116Smarcel expss << "tp-start: " << ts_regex << "thetp, 3\n"; 651240116Smarcel CHECK; 652240116Smarcel 653240116Smarcel w.start_tc("passtc"); 654240116Smarcel expss << "tc-start: " << ts_regex << "passtc\n"; 655240116Smarcel CHECK; 656240116Smarcel 657240116Smarcel w.end_tc("passed", ""); 658240116Smarcel expss << "tc-end: " << ts_regex << "passtc, passed\n"; 659240116Smarcel CHECK; 660240116Smarcel 661240116Smarcel w.start_tc("failtc"); 662240116Smarcel expss << "tc-start: " << ts_regex << "failtc\n"; 663240116Smarcel CHECK; 664240116Smarcel 665240116Smarcel w.end_tc("failed", "The reason"); 666240116Smarcel expss << "tc-end: " << ts_regex << "failtc, failed, The reason\n"; 667240116Smarcel CHECK; 668240116Smarcel 669240116Smarcel w.start_tc("skiptc"); 670240116Smarcel expss << "tc-start: " << ts_regex << "skiptc\n"; 671240116Smarcel CHECK; 672240116Smarcel 673240116Smarcel w.end_tc("skipped", "The reason"); 674240116Smarcel expss << "tc-end: " << ts_regex << "skiptc, skipped, The reason\n"; 675240116Smarcel CHECK; 676240116Smarcel 677240116Smarcel w.end_tp(""); 678240116Smarcel expss << "tp-end: " << ts_regex << "thetp\n"; 679240116Smarcel CHECK; 680240116Smarcel } 681240116Smarcel 682240116Smarcel { 683240116Smarcel RESET; 684240116Smarcel 685240116Smarcel impl::atf_tps_writer w(ss); 686240116Smarcel expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 687240116Smarcel CHECK; 688240116Smarcel 689240116Smarcel w.ntps(1); 690240116Smarcel expss << "tps-count: 1\n"; 691240116Smarcel CHECK; 692240116Smarcel 693240116Smarcel w.start_tp("thetp", 1); 694240116Smarcel expss << "tp-start: " << ts_regex << "thetp, 1\n"; 695240116Smarcel CHECK; 696240116Smarcel 697240116Smarcel w.start_tc("thetc"); 698240116Smarcel expss << "tc-start: " << ts_regex << "thetc\n"; 699240116Smarcel CHECK; 700240116Smarcel 701240116Smarcel w.stdout_tc("a line"); 702240116Smarcel expss << "tc-so:a line\n"; 703240116Smarcel CHECK; 704240116Smarcel 705240116Smarcel w.stdout_tc("another line"); 706240116Smarcel expss << "tc-so:another line\n"; 707240116Smarcel CHECK; 708240116Smarcel 709240116Smarcel w.stderr_tc("an error message"); 710240116Smarcel expss << "tc-se:an error message\n"; 711240116Smarcel CHECK; 712240116Smarcel 713240116Smarcel w.end_tc("passed", ""); 714240116Smarcel expss << "tc-end: " << ts_regex << "thetc, passed\n"; 715240116Smarcel CHECK; 716240116Smarcel 717240116Smarcel w.end_tp(""); 718240116Smarcel expss << "tp-end: " << ts_regex << "thetp\n"; 719240116Smarcel CHECK; 720240116Smarcel } 721240116Smarcel 722240116Smarcel { 723240116Smarcel RESET; 724240116Smarcel 725240116Smarcel impl::atf_tps_writer w(ss); 726240116Smarcel expss << "Content-Type: application/X-atf-tps; version=\"3\"\n\n"; 727240116Smarcel CHECK; 728240116Smarcel 729240116Smarcel w.ntps(1); 730240116Smarcel expss << "tps-count: 1\n"; 731240116Smarcel CHECK; 732240116Smarcel 733240116Smarcel w.start_tp("thetp", 0); 734240116Smarcel expss << "tp-start: " << ts_regex << "thetp, 0\n"; 735240116Smarcel CHECK; 736240116Smarcel 737240116Smarcel w.end_tp(""); 738240116Smarcel expss << "tp-end: " << ts_regex << "thetp\n"; 739240116Smarcel CHECK; 740240116Smarcel 741240116Smarcel w.info("foo", "bar"); 742240116Smarcel expss << "info: foo, bar\n"; 743240116Smarcel CHECK; 744240116Smarcel 745240116Smarcel w.info("baz", "second value"); 746240116Smarcel expss << "info: baz, second value\n"; 747240116Smarcel CHECK; 748240116Smarcel } 749240116Smarcel 750240116Smarcel#undef CHECK 751240116Smarcel#undef RESET 752240116Smarcel} 753240116Smarcel 754240116Smarcel// ------------------------------------------------------------------------- 755240116Smarcel// Tests for the free functions. 756240116Smarcel// ------------------------------------------------------------------------- 757240116Smarcel 758240116SmarcelATF_TEST_CASE(get_metadata_bad); 759240116SmarcelATF_TEST_CASE_HEAD(get_metadata_bad) {} 760240116SmarcelATF_TEST_CASE_BODY(get_metadata_bad) { 761240116Smarcel const atf::fs::path executable = get_helper(*this, "bad_metadata_helper"); 762240116Smarcel ATF_REQUIRE_THROW(atf::parser::parse_errors, 763240116Smarcel impl::get_metadata(executable, vars_map())); 764240116Smarcel} 765240116Smarcel 766240116SmarcelATF_TEST_CASE(get_metadata_zero_tcs); 767240116SmarcelATF_TEST_CASE_HEAD(get_metadata_zero_tcs) {} 768240116SmarcelATF_TEST_CASE_BODY(get_metadata_zero_tcs) { 769240116Smarcel const atf::fs::path executable = get_helper(*this, "zero_tcs_helper"); 770240116Smarcel ATF_REQUIRE_THROW(atf::parser::parse_errors, 771240116Smarcel impl::get_metadata(executable, vars_map())); 772240116Smarcel} 773240116Smarcel 774240116SmarcelATF_TEST_CASE(get_metadata_several_tcs); 775240116SmarcelATF_TEST_CASE_HEAD(get_metadata_several_tcs) {} 776240116SmarcelATF_TEST_CASE_BODY(get_metadata_several_tcs) { 777240116Smarcel const atf::fs::path executable = get_helper(*this, "several_tcs_helper"); 778240116Smarcel const impl::metadata md = impl::get_metadata(executable, vars_map()); 779240116Smarcel ATF_REQUIRE_EQ(3, md.test_cases.size()); 780240116Smarcel 781240116Smarcel { 782240116Smarcel const impl::test_cases_map::const_iterator iter = 783240116Smarcel md.test_cases.find("first"); 784240116Smarcel ATF_REQUIRE(iter != md.test_cases.end()); 785240116Smarcel 786240116Smarcel ATF_REQUIRE_EQ(4, (*iter).second.size()); 787240116Smarcel check_property((*iter).second, "descr", "Description 1"); 788240116Smarcel check_property((*iter).second, "has.cleanup", "false"); 789240116Smarcel check_property((*iter).second, "ident", "first"); 790240116Smarcel check_property((*iter).second, "timeout", "300"); 791240116Smarcel } 792240116Smarcel 793240116Smarcel { 794240116Smarcel const impl::test_cases_map::const_iterator iter = 795240116Smarcel md.test_cases.find("second"); 796240116Smarcel ATF_REQUIRE(iter != md.test_cases.end()); 797240116Smarcel 798240116Smarcel ATF_REQUIRE_EQ(5, (*iter).second.size()); 799240116Smarcel check_property((*iter).second, "descr", "Description 2"); 800240116Smarcel check_property((*iter).second, "has.cleanup", "true"); 801240116Smarcel check_property((*iter).second, "ident", "second"); 802240116Smarcel check_property((*iter).second, "timeout", "500"); 803240116Smarcel check_property((*iter).second, "X-property", "Custom property"); 804240116Smarcel } 805240116Smarcel 806240116Smarcel { 807240116Smarcel const impl::test_cases_map::const_iterator iter = 808240116Smarcel md.test_cases.find("third"); 809240116Smarcel ATF_REQUIRE(iter != md.test_cases.end()); 810240116Smarcel 811240116Smarcel ATF_REQUIRE_EQ(3, (*iter).second.size()); 812240116Smarcel check_property((*iter).second, "has.cleanup", "false"); 813240116Smarcel check_property((*iter).second, "ident", "third"); 814240116Smarcel check_property((*iter).second, "timeout", "300"); 815240116Smarcel } 816240116Smarcel} 817240116Smarcel 818240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_death); 819240116SmarcelATF_TEST_CASE_BODY(parse_test_case_result_expected_death) { 820240116Smarcel check_result("expected_death", -1, "foo bar", 821240116Smarcel detail::parse_test_case_result("expected_death: foo bar")); 822240116Smarcel 823240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 824240116Smarcel detail::parse_test_case_result("expected_death")); 825240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 826240116Smarcel detail::parse_test_case_result("expected_death(3): foo")); 827240116Smarcel} 828240116Smarcel 829240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_exit); 830240116SmarcelATF_TEST_CASE_BODY(parse_test_case_result_expected_exit) { 831240116Smarcel check_result("expected_exit", -1, "foo bar", 832240116Smarcel detail::parse_test_case_result("expected_exit: foo bar")); 833240116Smarcel check_result("expected_exit", -1, "foo bar", 834240116Smarcel detail::parse_test_case_result("expected_exit(): foo bar")); 835240116Smarcel check_result("expected_exit", 5, "foo bar", 836240116Smarcel detail::parse_test_case_result("expected_exit(5): foo bar")); 837240116Smarcel 838240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 839240116Smarcel detail::parse_test_case_result("expected_exit")); 840240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 841240116Smarcel detail::parse_test_case_result("expected_exit(")); 842240116Smarcel} 843240116Smarcel 844240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_failure); 845240116SmarcelATF_TEST_CASE_BODY(parse_test_case_result_expected_failure) { 846240116Smarcel check_result("expected_failure", -1, "foo bar", 847240116Smarcel detail::parse_test_case_result("expected_failure: foo bar")); 848240116Smarcel 849240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 850240116Smarcel detail::parse_test_case_result("expected_failure")); 851240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 852240116Smarcel detail::parse_test_case_result("expected_failure(3): foo")); 853240116Smarcel} 854240116Smarcel 855240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_signal); 856240116SmarcelATF_TEST_CASE_BODY(parse_test_case_result_expected_signal) { 857240116Smarcel check_result("expected_signal", -1, "foo bar", 858240116Smarcel detail::parse_test_case_result("expected_signal: foo bar")); 859240116Smarcel check_result("expected_signal", -1, "foo bar", 860240116Smarcel detail::parse_test_case_result("expected_signal(): foo bar")); 861240116Smarcel check_result("expected_signal", 5, "foo bar", 862240116Smarcel detail::parse_test_case_result("expected_signal(5): foo bar")); 863240116Smarcel 864240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 865240116Smarcel detail::parse_test_case_result("expected_signal")); 866240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 867240116Smarcel detail::parse_test_case_result("expected_signal(")); 868240116Smarcel} 869240116Smarcel 870240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_expected_timeout); 871240116SmarcelATF_TEST_CASE_BODY(parse_test_case_result_expected_timeout) { 872240116Smarcel check_result("expected_timeout", -1, "foo bar", 873240116Smarcel detail::parse_test_case_result("expected_timeout: foo bar")); 874240116Smarcel 875240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 876240116Smarcel detail::parse_test_case_result("expected_timeout")); 877240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 878240116Smarcel detail::parse_test_case_result("expected_timeout(3): foo")); 879240116Smarcel} 880240116Smarcel 881240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_failed); 882240116SmarcelATF_TEST_CASE_BODY(parse_test_case_result_failed) { 883240116Smarcel check_result("failed", -1, "foo bar", 884240116Smarcel detail::parse_test_case_result("failed: foo bar")); 885240116Smarcel 886240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 887240116Smarcel detail::parse_test_case_result("failed")); 888240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 889240116Smarcel detail::parse_test_case_result("failed(3): foo")); 890240116Smarcel} 891240116Smarcel 892240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_passed); 893240116SmarcelATF_TEST_CASE_BODY(parse_test_case_result_passed) { 894240116Smarcel check_result("passed", -1, "", 895240116Smarcel detail::parse_test_case_result("passed")); 896240116Smarcel 897240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 898240116Smarcel detail::parse_test_case_result("passed: foo")); 899240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 900240116Smarcel detail::parse_test_case_result("passed(3): foo")); 901240116Smarcel} 902240116Smarcel 903240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_skipped); 904240116SmarcelATF_TEST_CASE_BODY(parse_test_case_result_skipped) { 905240116Smarcel check_result("skipped", -1, "foo bar", 906240116Smarcel detail::parse_test_case_result("skipped: foo bar")); 907240116Smarcel 908240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 909240116Smarcel detail::parse_test_case_result("skipped")); 910240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 911240116Smarcel detail::parse_test_case_result("skipped(3): foo")); 912240116Smarcel} 913240116Smarcel 914240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(parse_test_case_result_unknown); 915240116SmarcelATF_TEST_CASE_BODY(parse_test_case_result_unknown) { 916240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 917240116Smarcel detail::parse_test_case_result("foo")); 918240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 919240116Smarcel detail::parse_test_case_result("bar: foo")); 920240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 921240116Smarcel detail::parse_test_case_result("baz: foo")); 922240116Smarcel} 923240116Smarcel 924240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_failed); 925240116SmarcelATF_TEST_CASE_BODY(read_test_case_result_failed) { 926240116Smarcel write_test_case_result("resfile", "failed: foo bar\n"); 927240116Smarcel const impl::test_case_result tcr = impl::read_test_case_result( 928240116Smarcel atf::fs::path("resfile")); 929240116Smarcel ATF_REQUIRE_EQ("failed", tcr.state()); 930240116Smarcel ATF_REQUIRE_EQ("foo bar", tcr.reason()); 931240116Smarcel} 932240116Smarcel 933240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_skipped); 934240116SmarcelATF_TEST_CASE_BODY(read_test_case_result_skipped) { 935240116Smarcel write_test_case_result("resfile", "skipped: baz bar\n"); 936240116Smarcel const impl::test_case_result tcr = impl::read_test_case_result( 937240116Smarcel atf::fs::path("resfile")); 938240116Smarcel ATF_REQUIRE_EQ("skipped", tcr.state()); 939240116Smarcel ATF_REQUIRE_EQ("baz bar", tcr.reason()); 940240116Smarcel} 941240116Smarcel 942240116Smarcel 943240116SmarcelATF_TEST_CASE(read_test_case_result_no_file); 944240116SmarcelATF_TEST_CASE_HEAD(read_test_case_result_no_file) {} 945240116SmarcelATF_TEST_CASE_BODY(read_test_case_result_no_file) { 946240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 947240116Smarcel impl::read_test_case_result(atf::fs::path("resfile"))); 948240116Smarcel} 949240116Smarcel 950240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_empty_file); 951240116SmarcelATF_TEST_CASE_BODY(read_test_case_result_empty_file) { 952240116Smarcel write_test_case_result("resfile", ""); 953240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 954240116Smarcel impl::read_test_case_result(atf::fs::path("resfile"))); 955240116Smarcel} 956240116Smarcel 957240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_invalid); 958240116SmarcelATF_TEST_CASE_BODY(read_test_case_result_invalid) { 959240116Smarcel write_test_case_result("resfile", "passed: hello\n"); 960240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 961240116Smarcel impl::read_test_case_result(atf::fs::path("resfile"))); 962240116Smarcel} 963240116Smarcel 964240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(read_test_case_result_multiline); 965240116SmarcelATF_TEST_CASE_BODY(read_test_case_result_multiline) { 966240116Smarcel write_test_case_result("resfile", "skipped: foo\nbar\n"); 967240116Smarcel const impl::test_case_result tcr = impl::read_test_case_result( 968240116Smarcel atf::fs::path("resfile")); 969240116Smarcel ATF_REQUIRE_EQ("skipped", tcr.state()); 970240116Smarcel ATF_REQUIRE_EQ("foo<<NEWLINE UNEXPECTED>>bar", tcr.reason()); 971240116Smarcel} 972240116Smarcel 973240116Smarcel// ------------------------------------------------------------------------- 974240116Smarcel// Main. 975240116Smarcel// ------------------------------------------------------------------------- 976240116Smarcel 977240116SmarcelATF_INIT_TEST_CASES(tcs) 978240116Smarcel{ 979240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_1); 980240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_2); 981240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_3); 982240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_4); 983240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_50); 984240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_51); 985240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_52); 986240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_53); 987240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_54); 988240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_55); 989240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_56); 990240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_57); 991240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_58); 992240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_59); 993240116Smarcel ATF_ADD_TEST_CASE(tcs, tp_60); 994240116Smarcel 995240116Smarcel ATF_ADD_TEST_CASE(tcs, atf_tps_writer); 996240116Smarcel 997240116Smarcel ATF_ADD_TEST_CASE(tcs, get_metadata_bad); 998240116Smarcel ATF_ADD_TEST_CASE(tcs, get_metadata_zero_tcs); 999240116Smarcel ATF_ADD_TEST_CASE(tcs, get_metadata_several_tcs); 1000240116Smarcel 1001240116Smarcel ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_death); 1002240116Smarcel ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_exit); 1003240116Smarcel ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_failure); 1004240116Smarcel ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_signal); 1005240116Smarcel ATF_ADD_TEST_CASE(tcs, parse_test_case_result_expected_timeout); 1006240116Smarcel ATF_ADD_TEST_CASE(tcs, parse_test_case_result_failed); 1007240116Smarcel ATF_ADD_TEST_CASE(tcs, parse_test_case_result_passed); 1008240116Smarcel ATF_ADD_TEST_CASE(tcs, parse_test_case_result_skipped); 1009240116Smarcel ATF_ADD_TEST_CASE(tcs, parse_test_case_result_unknown); 1010240116Smarcel 1011240116Smarcel ATF_ADD_TEST_CASE(tcs, read_test_case_result_failed); 1012240116Smarcel ATF_ADD_TEST_CASE(tcs, read_test_case_result_skipped); 1013240116Smarcel ATF_ADD_TEST_CASE(tcs, read_test_case_result_no_file); 1014240116Smarcel ATF_ADD_TEST_CASE(tcs, read_test_case_result_empty_file); 1015240116Smarcel ATF_ADD_TEST_CASE(tcs, read_test_case_result_multiline); 1016240116Smarcel ATF_ADD_TEST_CASE(tcs, read_test_case_result_invalid); 1017240116Smarcel 1018240116Smarcel // TODO: Add tests for run_test_case once all the missing functionality 1019240116Smarcel // is implemented. 1020240116Smarcel} 1021