1240116Smarcel// Copyright (c) 2007 The NetBSD Foundation, Inc. 2240116Smarcel// All rights reserved. 3240116Smarcel// 4240116Smarcel// Redistribution and use in source and binary forms, with or without 5240116Smarcel// modification, are permitted provided that the following conditions 6240116Smarcel// are met: 7240116Smarcel// 1. Redistributions of source code must retain the above copyright 8240116Smarcel// notice, this list of conditions and the following disclaimer. 9240116Smarcel// 2. Redistributions in binary form must reproduce the above copyright 10240116Smarcel// notice, this list of conditions and the following disclaimer in the 11240116Smarcel// documentation and/or other materials provided with the distribution. 12240116Smarcel// 13240116Smarcel// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 14240116Smarcel// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 15240116Smarcel// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 16240116Smarcel// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17240116Smarcel// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 18240116Smarcel// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19240116Smarcel// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 20240116Smarcel// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 21240116Smarcel// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 22240116Smarcel// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 23240116Smarcel// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 24240116Smarcel// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25240116Smarcel 26273929Sjmmv#include "atf-c++/utils.hpp" 27273929Sjmmv 28258289Sjmmvextern "C" { 29258289Sjmmv#include <sys/stat.h> 30258289Sjmmv#include <sys/wait.h> 31258289Sjmmv 32258289Sjmmv#include <fcntl.h> 33258289Sjmmv#include <unistd.h> 34258289Sjmmv} 35258289Sjmmv 36258289Sjmmv#include <cstdlib> 37240116Smarcel#include <iostream> 38258289Sjmmv#include <set> 39273929Sjmmv#include <sstream> 40258289Sjmmv#include <string> 41258289Sjmmv#include <vector> 42240116Smarcel 43273929Sjmmv#include <atf-c++.hpp> 44240116Smarcel 45258289Sjmmvstatic std::string 46273929Sjmmvread_file(const std::string& path) 47258289Sjmmv{ 48258289Sjmmv char buffer[1024]; 49258289Sjmmv 50273929Sjmmv const int fd = open(path.c_str(), O_RDONLY); 51258289Sjmmv if (fd == -1) 52273929Sjmmv ATF_FAIL("Cannot open " + path); 53258289Sjmmv const ssize_t length = read(fd, buffer, sizeof(buffer) - 1); 54258289Sjmmv close(fd); 55258289Sjmmv ATF_REQUIRE(length != -1); 56258289Sjmmv if (length == sizeof(buffer) - 1) 57258289Sjmmv ATF_FAIL("Internal buffer not long enough to read temporary file"); 58258289Sjmmv ((char *)buffer)[length] = '\0'; 59258289Sjmmv 60258289Sjmmv return buffer; 61258289Sjmmv} 62258289Sjmmv 63240116Smarcel// ------------------------------------------------------------------------ 64258289Sjmmv// Tests cases for the free functions. 65240116Smarcel// ------------------------------------------------------------------------ 66240116Smarcel 67258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(cat_file__empty); 68258289SjmmvATF_TEST_CASE_BODY(cat_file__empty) 69258289Sjmmv{ 70258289Sjmmv atf::utils::create_file("file.txt", ""); 71258289Sjmmv atf::utils::redirect(STDOUT_FILENO, "captured.txt"); 72258289Sjmmv atf::utils::cat_file("file.txt", "PREFIX"); 73258289Sjmmv std::cout.flush(); 74258289Sjmmv close(STDOUT_FILENO); 75240116Smarcel 76258289Sjmmv ATF_REQUIRE_EQ("", read_file("captured.txt")); 77258289Sjmmv} 78240116Smarcel 79258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(cat_file__one_line); 80258289SjmmvATF_TEST_CASE_BODY(cat_file__one_line) 81258289Sjmmv{ 82258289Sjmmv atf::utils::create_file("file.txt", "This is a single line\n"); 83258289Sjmmv atf::utils::redirect(STDOUT_FILENO, "captured.txt"); 84258289Sjmmv atf::utils::cat_file("file.txt", "PREFIX"); 85258289Sjmmv std::cout.flush(); 86258289Sjmmv close(STDOUT_FILENO); 87240116Smarcel 88258289Sjmmv ATF_REQUIRE_EQ("PREFIXThis is a single line\n", read_file("captured.txt")); 89258289Sjmmv} 90240116Smarcel 91258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(cat_file__several_lines); 92258289SjmmvATF_TEST_CASE_BODY(cat_file__several_lines) 93258289Sjmmv{ 94258289Sjmmv atf::utils::create_file("file.txt", "First\nSecond line\nAnd third\n"); 95258289Sjmmv atf::utils::redirect(STDOUT_FILENO, "captured.txt"); 96258289Sjmmv atf::utils::cat_file("file.txt", ">"); 97258289Sjmmv std::cout.flush(); 98258289Sjmmv close(STDOUT_FILENO); 99240116Smarcel 100258289Sjmmv ATF_REQUIRE_EQ(">First\n>Second line\n>And third\n", 101258289Sjmmv read_file("captured.txt")); 102258289Sjmmv} 103240116Smarcel 104258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(cat_file__no_newline_eof); 105258289SjmmvATF_TEST_CASE_BODY(cat_file__no_newline_eof) 106258289Sjmmv{ 107258289Sjmmv atf::utils::create_file("file.txt", "Foo\n bar baz"); 108258289Sjmmv atf::utils::redirect(STDOUT_FILENO, "captured.txt"); 109258289Sjmmv atf::utils::cat_file("file.txt", "PREFIX"); 110258289Sjmmv std::cout.flush(); 111258289Sjmmv close(STDOUT_FILENO); 112240116Smarcel 113258289Sjmmv ATF_REQUIRE_EQ("PREFIXFoo\nPREFIX bar baz", read_file("captured.txt")); 114258289Sjmmv} 115240116Smarcel 116258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(compare_file__empty__match); 117258289SjmmvATF_TEST_CASE_BODY(compare_file__empty__match) 118240116Smarcel{ 119258289Sjmmv atf::utils::create_file("test.txt", ""); 120258289Sjmmv ATF_REQUIRE(atf::utils::compare_file("test.txt", "")); 121240116Smarcel} 122258289Sjmmv 123258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(compare_file__empty__not_match); 124258289SjmmvATF_TEST_CASE_BODY(compare_file__empty__not_match) 125240116Smarcel{ 126258289Sjmmv atf::utils::create_file("test.txt", ""); 127258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "\n")); 128258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "foo")); 129258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", " ")); 130258289Sjmmv} 131240116Smarcel 132258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(compare_file__short__match); 133258289SjmmvATF_TEST_CASE_BODY(compare_file__short__match) 134258289Sjmmv{ 135258289Sjmmv atf::utils::create_file("test.txt", "this is a short file"); 136258289Sjmmv ATF_REQUIRE(atf::utils::compare_file("test.txt", "this is a short file")); 137240116Smarcel} 138240116Smarcel 139258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(compare_file__short__not_match); 140258289SjmmvATF_TEST_CASE_BODY(compare_file__short__not_match) 141240116Smarcel{ 142258289Sjmmv atf::utils::create_file("test.txt", "this is a short file"); 143258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "")); 144258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "\n")); 145258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "this is a Short file")); 146258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "this is a short fil")); 147258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "this is a short file ")); 148240116Smarcel} 149258289Sjmmv 150258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(compare_file__long__match); 151258289SjmmvATF_TEST_CASE_BODY(compare_file__long__match) 152240116Smarcel{ 153258289Sjmmv char long_contents[3456]; 154258289Sjmmv size_t i = 0; 155258289Sjmmv for (; i < sizeof(long_contents) - 1; i++) 156258289Sjmmv long_contents[i] = '0' + (i % 10); 157258289Sjmmv long_contents[i] = '\0'; 158258289Sjmmv atf::utils::create_file("test.txt", long_contents); 159240116Smarcel 160258289Sjmmv ATF_REQUIRE(atf::utils::compare_file("test.txt", long_contents)); 161258289Sjmmv} 162240116Smarcel 163258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(compare_file__long__not_match); 164258289SjmmvATF_TEST_CASE_BODY(compare_file__long__not_match) 165258289Sjmmv{ 166258289Sjmmv char long_contents[3456]; 167258289Sjmmv size_t i = 0; 168258289Sjmmv for (; i < sizeof(long_contents) - 1; i++) 169258289Sjmmv long_contents[i] = '0' + (i % 10); 170258289Sjmmv long_contents[i] = '\0'; 171258289Sjmmv atf::utils::create_file("test.txt", long_contents); 172258289Sjmmv 173258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "")); 174258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "\n")); 175258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", "0123456789")); 176258289Sjmmv long_contents[i - 1] = 'Z'; 177258289Sjmmv ATF_REQUIRE(!atf::utils::compare_file("test.txt", long_contents)); 178240116Smarcel} 179240116Smarcel 180258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(copy_file__empty); 181258289SjmmvATF_TEST_CASE_BODY(copy_file__empty) 182240116Smarcel{ 183258289Sjmmv atf::utils::create_file("src.txt", ""); 184258289Sjmmv ATF_REQUIRE(chmod("src.txt", 0520) != -1); 185258289Sjmmv 186258289Sjmmv atf::utils::copy_file("src.txt", "dest.txt"); 187258289Sjmmv ATF_REQUIRE(atf::utils::compare_file("dest.txt", "")); 188258289Sjmmv struct stat sb; 189258289Sjmmv ATF_REQUIRE(stat("dest.txt", &sb) != -1); 190258289Sjmmv ATF_REQUIRE_EQ(0520, sb.st_mode & 0xfff); 191240116Smarcel} 192258289Sjmmv 193258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(copy_file__some_contents); 194258289SjmmvATF_TEST_CASE_BODY(copy_file__some_contents) 195240116Smarcel{ 196258289Sjmmv atf::utils::create_file("src.txt", "This is a\ntest file\n"); 197258289Sjmmv atf::utils::copy_file("src.txt", "dest.txt"); 198258289Sjmmv ATF_REQUIRE(atf::utils::compare_file("dest.txt", "This is a\ntest file\n")); 199258289Sjmmv} 200240116Smarcel 201258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(create_file); 202258289SjmmvATF_TEST_CASE_BODY(create_file) 203258289Sjmmv{ 204258289Sjmmv atf::utils::create_file("test.txt", "This is a %d test"); 205240116Smarcel 206258289Sjmmv ATF_REQUIRE_EQ("This is a %d test", read_file("test.txt")); 207240116Smarcel} 208240116Smarcel 209258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(file_exists); 210258289SjmmvATF_TEST_CASE_BODY(file_exists) 211240116Smarcel{ 212258289Sjmmv atf::utils::create_file("test.txt", "foo"); 213258289Sjmmv 214258289Sjmmv ATF_REQUIRE( atf::utils::file_exists("test.txt")); 215258289Sjmmv ATF_REQUIRE( atf::utils::file_exists("./test.txt")); 216258289Sjmmv ATF_REQUIRE(!atf::utils::file_exists("./test.tx")); 217258289Sjmmv ATF_REQUIRE(!atf::utils::file_exists("test.txt2")); 218240116Smarcel} 219258289Sjmmv 220258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(fork); 221258289SjmmvATF_TEST_CASE_BODY(fork) 222240116Smarcel{ 223258289Sjmmv std::cout << "Should not get into child\n"; 224258289Sjmmv std::cerr << "Should not get into child\n"; 225258289Sjmmv pid_t pid = atf::utils::fork(); 226258289Sjmmv if (pid == 0) { 227258289Sjmmv std::cout << "Child stdout\n"; 228258289Sjmmv std::cerr << "Child stderr\n"; 229258289Sjmmv exit(EXIT_SUCCESS); 230258289Sjmmv } 231240116Smarcel 232258289Sjmmv int status; 233258289Sjmmv ATF_REQUIRE(waitpid(pid, &status, 0) != -1); 234258289Sjmmv ATF_REQUIRE(WIFEXITED(status)); 235258289Sjmmv ATF_REQUIRE_EQ(EXIT_SUCCESS, WEXITSTATUS(status)); 236258289Sjmmv 237273929Sjmmv std::ostringstream out_name; 238273929Sjmmv out_name << "atf_utils_fork_" << pid << "_out.txt"; 239273929Sjmmv std::ostringstream err_name; 240273929Sjmmv err_name << "atf_utils_fork_" << pid << "_err.txt"; 241273929Sjmmv 242273929Sjmmv ATF_REQUIRE_EQ("Child stdout\n", read_file(out_name.str())); 243273929Sjmmv ATF_REQUIRE_EQ("Child stderr\n", read_file(err_name.str())); 244240116Smarcel} 245240116Smarcel 246258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(grep_collection__set); 247258289SjmmvATF_TEST_CASE_BODY(grep_collection__set) 248240116Smarcel{ 249258289Sjmmv std::set< std::string > strings; 250258289Sjmmv strings.insert("First"); 251258289Sjmmv strings.insert("Second"); 252258289Sjmmv 253258289Sjmmv ATF_REQUIRE( atf::utils::grep_collection("irs", strings)); 254258289Sjmmv ATF_REQUIRE( atf::utils::grep_collection("cond", strings)); 255258289Sjmmv ATF_REQUIRE(!atf::utils::grep_collection("Third", strings)); 256240116Smarcel} 257258289Sjmmv 258258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(grep_collection__vector); 259258289SjmmvATF_TEST_CASE_BODY(grep_collection__vector) 260240116Smarcel{ 261258289Sjmmv std::vector< std::string > strings; 262258289Sjmmv strings.push_back("First"); 263258289Sjmmv strings.push_back("Second"); 264240116Smarcel 265258289Sjmmv ATF_REQUIRE( atf::utils::grep_collection("irs", strings)); 266258289Sjmmv ATF_REQUIRE( atf::utils::grep_collection("cond", strings)); 267258289Sjmmv ATF_REQUIRE(!atf::utils::grep_collection("Third", strings)); 268240116Smarcel} 269240116Smarcel 270258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(grep_file); 271258289SjmmvATF_TEST_CASE_BODY(grep_file) 272240116Smarcel{ 273258289Sjmmv atf::utils::create_file("test.txt", "line1\nthe second line\naaaabbbb\n"); 274258289Sjmmv 275258289Sjmmv ATF_REQUIRE(atf::utils::grep_file("line1", "test.txt")); 276258289Sjmmv ATF_REQUIRE(atf::utils::grep_file("second line", "test.txt")); 277258289Sjmmv ATF_REQUIRE(atf::utils::grep_file("aa.*bb", "test.txt")); 278258289Sjmmv ATF_REQUIRE(!atf::utils::grep_file("foo", "test.txt")); 279258289Sjmmv ATF_REQUIRE(!atf::utils::grep_file("bar", "test.txt")); 280258289Sjmmv ATF_REQUIRE(!atf::utils::grep_file("aaaaa", "test.txt")); 281240116Smarcel} 282258289Sjmmv 283258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(grep_string); 284258289SjmmvATF_TEST_CASE_BODY(grep_string) 285240116Smarcel{ 286258289Sjmmv const char *str = "a string - aaaabbbb"; 287258289Sjmmv ATF_REQUIRE(atf::utils::grep_string("a string", str)); 288258289Sjmmv ATF_REQUIRE(atf::utils::grep_string("^a string", str)); 289258289Sjmmv ATF_REQUIRE(atf::utils::grep_string("aaaabbbb$", str)); 290258289Sjmmv ATF_REQUIRE(atf::utils::grep_string("aa.*bb", str)); 291258289Sjmmv ATF_REQUIRE(!atf::utils::grep_string("foo", str)); 292258289Sjmmv ATF_REQUIRE(!atf::utils::grep_string("bar", str)); 293258289Sjmmv ATF_REQUIRE(!atf::utils::grep_string("aaaaa", str)); 294258289Sjmmv} 295240116Smarcel 296258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(redirect__stdout); 297258289SjmmvATF_TEST_CASE_BODY(redirect__stdout) 298258289Sjmmv{ 299258289Sjmmv std::cout << "Buffer this"; 300258289Sjmmv atf::utils::redirect(STDOUT_FILENO, "captured.txt"); 301258289Sjmmv std::cout << "The printed message"; 302258289Sjmmv std::cout.flush(); 303240116Smarcel 304258289Sjmmv ATF_REQUIRE_EQ("The printed message", read_file("captured.txt")); 305240116Smarcel} 306240116Smarcel 307258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(redirect__stderr); 308258289SjmmvATF_TEST_CASE_BODY(redirect__stderr) 309240116Smarcel{ 310258289Sjmmv std::cerr << "Buffer this"; 311258289Sjmmv atf::utils::redirect(STDERR_FILENO, "captured.txt"); 312258289Sjmmv std::cerr << "The printed message"; 313258289Sjmmv std::cerr.flush(); 314258289Sjmmv 315258289Sjmmv ATF_REQUIRE_EQ("The printed message", read_file("captured.txt")); 316240116Smarcel} 317258289Sjmmv 318258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(redirect__other); 319258289SjmmvATF_TEST_CASE_BODY(redirect__other) 320240116Smarcel{ 321258289Sjmmv const std::string message = "Foo bar\nbaz\n"; 322258289Sjmmv atf::utils::redirect(15, "captured.txt"); 323258289Sjmmv ATF_REQUIRE(write(15, message.c_str(), message.length()) != -1); 324258289Sjmmv close(15); 325240116Smarcel 326258289Sjmmv ATF_REQUIRE_EQ(message, read_file("captured.txt")); 327258289Sjmmv} 328240116Smarcel 329258289Sjmmvstatic void 330258289Sjmmvfork_and_wait(const int exitstatus, const char* expout, const char* experr) 331258289Sjmmv{ 332258289Sjmmv const pid_t pid = atf::utils::fork(); 333258289Sjmmv if (pid == 0) { 334258289Sjmmv std::cout << "Some output\n"; 335258289Sjmmv std::cerr << "Some error\n"; 336258289Sjmmv exit(123); 337240116Smarcel } 338258289Sjmmv atf::utils::wait(pid, exitstatus, expout, experr); 339258289Sjmmv exit(EXIT_SUCCESS); 340240116Smarcel} 341240116Smarcel 342258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(wait__ok); 343258289SjmmvATF_TEST_CASE_BODY(wait__ok) 344240116Smarcel{ 345258289Sjmmv const pid_t control = fork(); 346258289Sjmmv ATF_REQUIRE(control != -1); 347258289Sjmmv if (control == 0) 348258289Sjmmv fork_and_wait(123, "Some output\n", "Some error\n"); 349258289Sjmmv else { 350258289Sjmmv int status; 351258289Sjmmv ATF_REQUIRE(waitpid(control, &status, 0) != -1); 352258289Sjmmv ATF_REQUIRE(WIFEXITED(status)); 353258289Sjmmv ATF_REQUIRE_EQ(EXIT_SUCCESS, WEXITSTATUS(status)); 354258289Sjmmv } 355240116Smarcel} 356258289Sjmmv 357273929SjmmvATF_TEST_CASE_WITHOUT_HEAD(wait__ok_nested); 358273929SjmmvATF_TEST_CASE_BODY(wait__ok_nested) 359273929Sjmmv{ 360273929Sjmmv const pid_t parent = atf::utils::fork(); 361273929Sjmmv ATF_REQUIRE(parent != -1); 362273929Sjmmv if (parent == 0) { 363273929Sjmmv const pid_t child = atf::utils::fork(); 364273929Sjmmv ATF_REQUIRE(child != -1); 365273929Sjmmv if (child == 0) { 366273929Sjmmv std::cerr.flush(); 367273929Sjmmv std::cout << "Child output\n"; 368273929Sjmmv std::cout.flush(); 369273929Sjmmv std::cerr << "Child error\n"; 370273929Sjmmv std::exit(50); 371273929Sjmmv } else { 372273929Sjmmv std::cout << "Parent output\n"; 373273929Sjmmv std::cerr << "Parent error\n"; 374273929Sjmmv atf::utils::wait(child, 50, "Child output\n", "Child error\n"); 375273929Sjmmv std::exit(40); 376273929Sjmmv } 377273929Sjmmv } else { 378273929Sjmmv atf::utils::wait(parent, 40, 379273929Sjmmv "Parent output\n" 380273929Sjmmv "subprocess stdout: Child output\n" 381273929Sjmmv "subprocess stderr: Child error\n", 382273929Sjmmv "Parent error\n"); 383273929Sjmmv } 384273929Sjmmv} 385273929Sjmmv 386258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(wait__invalid_exitstatus); 387258289SjmmvATF_TEST_CASE_BODY(wait__invalid_exitstatus) 388240116Smarcel{ 389258289Sjmmv const pid_t control = fork(); 390258289Sjmmv ATF_REQUIRE(control != -1); 391258289Sjmmv if (control == 0) 392258289Sjmmv fork_and_wait(120, "Some output\n", "Some error\n"); 393258289Sjmmv else { 394258289Sjmmv int status; 395258289Sjmmv ATF_REQUIRE(waitpid(control, &status, 0) != -1); 396258289Sjmmv ATF_REQUIRE(WIFEXITED(status)); 397258289Sjmmv ATF_REQUIRE_EQ(EXIT_FAILURE, WEXITSTATUS(status)); 398258289Sjmmv } 399258289Sjmmv} 400240116Smarcel 401258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(wait__invalid_stdout); 402258289SjmmvATF_TEST_CASE_BODY(wait__invalid_stdout) 403258289Sjmmv{ 404258289Sjmmv const pid_t control = fork(); 405258289Sjmmv ATF_REQUIRE(control != -1); 406258289Sjmmv if (control == 0) 407258289Sjmmv fork_and_wait(123, "Some output foo\n", "Some error\n"); 408258289Sjmmv else { 409258289Sjmmv int status; 410258289Sjmmv ATF_REQUIRE(waitpid(control, &status, 0) != -1); 411258289Sjmmv ATF_REQUIRE(WIFEXITED(status)); 412258289Sjmmv ATF_REQUIRE_EQ(EXIT_FAILURE, WEXITSTATUS(status)); 413240116Smarcel } 414240116Smarcel} 415240116Smarcel 416258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(wait__invalid_stderr); 417258289SjmmvATF_TEST_CASE_BODY(wait__invalid_stderr) 418240116Smarcel{ 419258289Sjmmv const pid_t control = fork(); 420258289Sjmmv ATF_REQUIRE(control != -1); 421258289Sjmmv if (control == 0) 422258289Sjmmv fork_and_wait(123, "Some output\n", "Some error foo\n"); 423258289Sjmmv else { 424258289Sjmmv int status; 425258289Sjmmv ATF_REQUIRE(waitpid(control, &status, 0) != -1); 426258289Sjmmv ATF_REQUIRE(WIFEXITED(status)); 427258289Sjmmv ATF_REQUIRE_EQ(EXIT_FAILURE, WEXITSTATUS(status)); 428258289Sjmmv } 429240116Smarcel} 430258289Sjmmv 431258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(wait__save_stdout); 432258289SjmmvATF_TEST_CASE_BODY(wait__save_stdout) 433240116Smarcel{ 434258289Sjmmv const pid_t control = fork(); 435258289Sjmmv ATF_REQUIRE(control != -1); 436258289Sjmmv if (control == 0) 437258289Sjmmv fork_and_wait(123, "save:my-output.txt", "Some error\n"); 438258289Sjmmv else { 439258289Sjmmv int status; 440258289Sjmmv ATF_REQUIRE(waitpid(control, &status, 0) != -1); 441258289Sjmmv ATF_REQUIRE(WIFEXITED(status)); 442258289Sjmmv ATF_REQUIRE_EQ(EXIT_SUCCESS, WEXITSTATUS(status)); 443240116Smarcel 444258289Sjmmv ATF_REQUIRE(atf::utils::compare_file("my-output.txt", "Some output\n")); 445258289Sjmmv } 446258289Sjmmv} 447240116Smarcel 448258289SjmmvATF_TEST_CASE_WITHOUT_HEAD(wait__save_stderr); 449258289SjmmvATF_TEST_CASE_BODY(wait__save_stderr) 450258289Sjmmv{ 451258289Sjmmv const pid_t control = fork(); 452258289Sjmmv ATF_REQUIRE(control != -1); 453258289Sjmmv if (control == 0) 454258289Sjmmv fork_and_wait(123, "Some output\n", "save:my-output.txt"); 455258289Sjmmv else { 456258289Sjmmv int status; 457258289Sjmmv ATF_REQUIRE(waitpid(control, &status, 0) != -1); 458258289Sjmmv ATF_REQUIRE(WIFEXITED(status)); 459258289Sjmmv ATF_REQUIRE_EQ(EXIT_SUCCESS, WEXITSTATUS(status)); 460240116Smarcel 461258289Sjmmv ATF_REQUIRE(atf::utils::compare_file("my-output.txt", "Some error\n")); 462258289Sjmmv } 463240116Smarcel} 464240116Smarcel 465240116Smarcel// ------------------------------------------------------------------------ 466240116Smarcel// Main. 467240116Smarcel// ------------------------------------------------------------------------ 468240116Smarcel 469240116SmarcelATF_INIT_TEST_CASES(tcs) 470240116Smarcel{ 471258289Sjmmv // Add the test for the free functions. 472258289Sjmmv ATF_ADD_TEST_CASE(tcs, cat_file__empty); 473258289Sjmmv ATF_ADD_TEST_CASE(tcs, cat_file__one_line); 474258289Sjmmv ATF_ADD_TEST_CASE(tcs, cat_file__several_lines); 475258289Sjmmv ATF_ADD_TEST_CASE(tcs, cat_file__no_newline_eof); 476240116Smarcel 477258289Sjmmv ATF_ADD_TEST_CASE(tcs, compare_file__empty__match); 478258289Sjmmv ATF_ADD_TEST_CASE(tcs, compare_file__empty__not_match); 479258289Sjmmv ATF_ADD_TEST_CASE(tcs, compare_file__short__match); 480258289Sjmmv ATF_ADD_TEST_CASE(tcs, compare_file__short__not_match); 481258289Sjmmv ATF_ADD_TEST_CASE(tcs, compare_file__long__match); 482258289Sjmmv ATF_ADD_TEST_CASE(tcs, compare_file__long__not_match); 483258289Sjmmv 484258289Sjmmv ATF_ADD_TEST_CASE(tcs, copy_file__empty); 485258289Sjmmv ATF_ADD_TEST_CASE(tcs, copy_file__some_contents); 486258289Sjmmv 487258289Sjmmv ATF_ADD_TEST_CASE(tcs, create_file); 488258289Sjmmv 489258289Sjmmv ATF_ADD_TEST_CASE(tcs, file_exists); 490258289Sjmmv 491258289Sjmmv ATF_ADD_TEST_CASE(tcs, fork); 492258289Sjmmv 493258289Sjmmv ATF_ADD_TEST_CASE(tcs, grep_collection__set); 494258289Sjmmv ATF_ADD_TEST_CASE(tcs, grep_collection__vector); 495258289Sjmmv ATF_ADD_TEST_CASE(tcs, grep_file); 496258289Sjmmv ATF_ADD_TEST_CASE(tcs, grep_string); 497258289Sjmmv 498258289Sjmmv ATF_ADD_TEST_CASE(tcs, redirect__stdout); 499258289Sjmmv ATF_ADD_TEST_CASE(tcs, redirect__stderr); 500258289Sjmmv ATF_ADD_TEST_CASE(tcs, redirect__other); 501258289Sjmmv 502258289Sjmmv ATF_ADD_TEST_CASE(tcs, wait__ok); 503273929Sjmmv ATF_ADD_TEST_CASE(tcs, wait__ok_nested); 504258289Sjmmv ATF_ADD_TEST_CASE(tcs, wait__invalid_exitstatus); 505258289Sjmmv ATF_ADD_TEST_CASE(tcs, wait__invalid_stdout); 506258289Sjmmv ATF_ADD_TEST_CASE(tcs, wait__invalid_stderr); 507258289Sjmmv ATF_ADD_TEST_CASE(tcs, wait__save_stdout); 508258289Sjmmv ATF_ADD_TEST_CASE(tcs, wait__save_stderr); 509240116Smarcel} 510