1 // 2 // Automated Testing Framework (atf) 3 // 4 // Copyright (c) 2007, 2008, 2009, 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 extern "C" { 31 #include <signal.h> 32 #include <unistd.h> 33 } 34 35 #include <cstdlib> 36 #include <fstream> 37 #include <iostream> 38 39 #include "atf-c++/fs.hpp" 40 #include "atf-c++/macros.hpp" 41 42 // ------------------------------------------------------------------------ 43 // Helper tests for "t_config". 44 // ------------------------------------------------------------------------ 45 46 ATF_TEST_CASE(config_unset); 47 ATF_TEST_CASE_HEAD(config_unset) 48 { 49 set_md_var("descr", "Helper test case for the t_config test program"); 50 } 51 ATF_TEST_CASE_BODY(config_unset) 52 { 53 ATF_CHECK(!has_config_var("test")); 54 } 55 56 ATF_TEST_CASE(config_empty); 57 ATF_TEST_CASE_HEAD(config_empty) 58 { 59 set_md_var("descr", "Helper test case for the t_config test program"); 60 } 61 ATF_TEST_CASE_BODY(config_empty) 62 { 63 ATF_CHECK_EQUAL(get_config_var("test"), ""); 64 } 65 66 ATF_TEST_CASE(config_value); 67 ATF_TEST_CASE_HEAD(config_value) 68 { 69 set_md_var("descr", "Helper test case for the t_config test program"); 70 } 71 ATF_TEST_CASE_BODY(config_value) 72 { 73 ATF_CHECK_EQUAL(get_config_var("test"), "foo"); 74 } 75 76 ATF_TEST_CASE(config_multi_value); 77 ATF_TEST_CASE_HEAD(config_multi_value) 78 { 79 set_md_var("descr", "Helper test case for the t_config test program"); 80 } 81 ATF_TEST_CASE_BODY(config_multi_value) 82 { 83 ATF_CHECK_EQUAL(get_config_var("test"), "foo bar"); 84 } 85 86 // ------------------------------------------------------------------------ 87 // Helper tests for "t_expect". 88 // ------------------------------------------------------------------------ 89 90 ATF_TEST_CASE_WITHOUT_HEAD(expect_pass_and_pass); 91 ATF_TEST_CASE_BODY(expect_pass_and_pass) 92 { 93 expect_pass(); 94 } 95 96 ATF_TEST_CASE_WITHOUT_HEAD(expect_pass_but_fail_requirement); 97 ATF_TEST_CASE_BODY(expect_pass_but_fail_requirement) 98 { 99 expect_pass(); 100 fail("Some reason"); 101 } 102 103 ATF_TEST_CASE_WITHOUT_HEAD(expect_pass_but_fail_check); 104 ATF_TEST_CASE_BODY(expect_pass_but_fail_check) 105 { 106 expect_pass(); 107 fail_nonfatal("Some reason"); 108 } 109 110 ATF_TEST_CASE_WITHOUT_HEAD(expect_fail_and_fail_requirement); 111 ATF_TEST_CASE_BODY(expect_fail_and_fail_requirement) 112 { 113 expect_fail("Fail reason"); 114 fail("The failure"); 115 expect_pass(); 116 } 117 118 ATF_TEST_CASE_WITHOUT_HEAD(expect_fail_and_fail_check); 119 ATF_TEST_CASE_BODY(expect_fail_and_fail_check) 120 { 121 expect_fail("Fail first"); 122 fail_nonfatal("abc"); 123 expect_pass(); 124 125 expect_fail("And fail again"); 126 fail_nonfatal("def"); 127 expect_pass(); 128 } 129 130 ATF_TEST_CASE_WITHOUT_HEAD(expect_fail_but_pass); 131 ATF_TEST_CASE_BODY(expect_fail_but_pass) 132 { 133 expect_fail("Fail first"); 134 fail_nonfatal("abc"); 135 expect_pass(); 136 137 expect_fail("Will not fail"); 138 expect_pass(); 139 140 expect_fail("And fail again"); 141 fail_nonfatal("def"); 142 expect_pass(); 143 } 144 145 ATF_TEST_CASE_WITHOUT_HEAD(expect_exit_any_and_exit); 146 ATF_TEST_CASE_BODY(expect_exit_any_and_exit) 147 { 148 expect_exit(-1, "Call will exit"); 149 std::exit(EXIT_SUCCESS); 150 } 151 152 ATF_TEST_CASE_WITHOUT_HEAD(expect_exit_code_and_exit); 153 ATF_TEST_CASE_BODY(expect_exit_code_and_exit) 154 { 155 expect_exit(123, "Call will exit"); 156 std::exit(123); 157 } 158 159 ATF_TEST_CASE_WITHOUT_HEAD(expect_exit_but_pass); 160 ATF_TEST_CASE_BODY(expect_exit_but_pass) 161 { 162 expect_exit(-1, "Call won't exit"); 163 } 164 165 ATF_TEST_CASE_WITHOUT_HEAD(expect_signal_any_and_signal); 166 ATF_TEST_CASE_BODY(expect_signal_any_and_signal) 167 { 168 expect_signal(-1, "Call will signal"); 169 ::kill(getpid(), SIGKILL); 170 } 171 172 ATF_TEST_CASE_WITHOUT_HEAD(expect_signal_no_and_signal); 173 ATF_TEST_CASE_BODY(expect_signal_no_and_signal) 174 { 175 expect_signal(SIGHUP, "Call will signal"); 176 ::kill(getpid(), SIGHUP); 177 } 178 179 ATF_TEST_CASE_WITHOUT_HEAD(expect_signal_but_pass); 180 ATF_TEST_CASE_BODY(expect_signal_but_pass) 181 { 182 expect_signal(-1, "Call won't signal"); 183 } 184 185 ATF_TEST_CASE_WITHOUT_HEAD(expect_death_and_exit); 186 ATF_TEST_CASE_BODY(expect_death_and_exit) 187 { 188 expect_death("Exit case"); 189 std::exit(123); 190 } 191 192 ATF_TEST_CASE_WITHOUT_HEAD(expect_death_and_signal); 193 ATF_TEST_CASE_BODY(expect_death_and_signal) 194 { 195 expect_death("Signal case"); 196 kill(getpid(), SIGKILL); 197 } 198 199 ATF_TEST_CASE_WITHOUT_HEAD(expect_death_but_pass); 200 ATF_TEST_CASE_BODY(expect_death_but_pass) 201 { 202 expect_death("Call won't die"); 203 } 204 205 ATF_TEST_CASE(expect_timeout_and_hang); 206 ATF_TEST_CASE_HEAD(expect_timeout_and_hang) 207 { 208 set_md_var("timeout", "1"); 209 } 210 ATF_TEST_CASE_BODY(expect_timeout_and_hang) 211 { 212 expect_timeout("Will overrun"); 213 ::sleep(5); 214 } 215 216 ATF_TEST_CASE(expect_timeout_but_pass); 217 ATF_TEST_CASE_HEAD(expect_timeout_but_pass) 218 { 219 set_md_var("timeout", "1"); 220 } 221 ATF_TEST_CASE_BODY(expect_timeout_but_pass) 222 { 223 expect_timeout("Will just exit"); 224 } 225 226 // ------------------------------------------------------------------------ 227 // Helper tests for "t_fork". 228 // ------------------------------------------------------------------------ 229 230 ATF_TEST_CASE(fork_stop); 231 ATF_TEST_CASE_HEAD(fork_stop) 232 { 233 set_md_var("descr", "Helper test case for the t_fork test program"); 234 } 235 ATF_TEST_CASE_BODY(fork_stop) 236 { 237 std::ofstream os(get_config_var("pidfile").c_str()); 238 os << ::getpid() << std::endl; 239 os.close(); 240 std::cout << "Wrote pid file" << std::endl; 241 std::cout << "Waiting for done file" << std::endl; 242 while (::access(get_config_var("donefile").c_str(), F_OK) != 0) 243 ::usleep(10000); 244 std::cout << "Exiting" << std::endl; 245 } 246 247 // ------------------------------------------------------------------------ 248 // Helper tests for "t_meta_data". 249 // ------------------------------------------------------------------------ 250 251 ATF_TEST_CASE(metadata_no_descr); 252 ATF_TEST_CASE_HEAD(metadata_no_descr) 253 { 254 } 255 ATF_TEST_CASE_BODY(metadata_no_descr) 256 { 257 } 258 259 ATF_TEST_CASE_WITHOUT_HEAD(metadata_no_head); 260 ATF_TEST_CASE_BODY(metadata_no_head) 261 { 262 } 263 264 // ------------------------------------------------------------------------ 265 // Helper tests for "t_srcdir". 266 // ------------------------------------------------------------------------ 267 268 ATF_TEST_CASE(srcdir_exists); 269 ATF_TEST_CASE_HEAD(srcdir_exists) 270 { 271 set_md_var("descr", "Helper test case for the t_srcdir test program"); 272 } 273 ATF_TEST_CASE_BODY(srcdir_exists) 274 { 275 if (!atf::fs::exists(atf::fs::path(get_config_var("srcdir")) / 276 "datafile")) 277 ATF_FAIL("Cannot find datafile"); 278 } 279 280 // ------------------------------------------------------------------------ 281 // Helper tests for "t_result". 282 // ------------------------------------------------------------------------ 283 284 ATF_TEST_CASE(result_pass); 285 ATF_TEST_CASE_HEAD(result_pass) { } 286 ATF_TEST_CASE_BODY(result_pass) 287 { 288 std::cout << "msg\n"; 289 } 290 291 ATF_TEST_CASE(result_fail); 292 ATF_TEST_CASE_HEAD(result_fail) { } 293 ATF_TEST_CASE_BODY(result_fail) 294 { 295 std::cout << "msg\n"; 296 ATF_FAIL("Failure reason"); 297 } 298 299 ATF_TEST_CASE(result_skip); 300 ATF_TEST_CASE_HEAD(result_skip) { } 301 ATF_TEST_CASE_BODY(result_skip) 302 { 303 std::cout << "msg\n"; 304 ATF_SKIP("Skipped reason"); 305 } 306 307 ATF_TEST_CASE(result_newlines_fail); 308 ATF_TEST_CASE_HEAD(result_newlines_fail) 309 { 310 set_md_var("descr", "Helper test case for the t_result test program"); 311 } 312 ATF_TEST_CASE_BODY(result_newlines_fail) 313 { 314 ATF_FAIL("First line\nSecond line"); 315 } 316 317 ATF_TEST_CASE(result_newlines_skip); 318 ATF_TEST_CASE_HEAD(result_newlines_skip) 319 { 320 set_md_var("descr", "Helper test case for the t_result test program"); 321 } 322 ATF_TEST_CASE_BODY(result_newlines_skip) 323 { 324 ATF_SKIP("First line\nSecond line"); 325 } 326 327 ATF_TEST_CASE(result_exception); 328 ATF_TEST_CASE_HEAD(result_exception) { } 329 ATF_TEST_CASE_BODY(result_exception) 330 { 331 throw std::runtime_error("This is unhandled"); 332 } 333 334 // ------------------------------------------------------------------------ 335 // Main. 336 // ------------------------------------------------------------------------ 337 338 ATF_INIT_TEST_CASES(tcs) 339 { 340 // Add helper tests for t_config. 341 ATF_ADD_TEST_CASE(tcs, config_unset); 342 ATF_ADD_TEST_CASE(tcs, config_empty); 343 ATF_ADD_TEST_CASE(tcs, config_value); 344 ATF_ADD_TEST_CASE(tcs, config_multi_value); 345 346 // Add helper tests for t_expect. 347 ATF_ADD_TEST_CASE(tcs, expect_pass_and_pass); 348 ATF_ADD_TEST_CASE(tcs, expect_pass_but_fail_requirement); 349 ATF_ADD_TEST_CASE(tcs, expect_pass_but_fail_check); 350 ATF_ADD_TEST_CASE(tcs, expect_fail_and_fail_requirement); 351 ATF_ADD_TEST_CASE(tcs, expect_fail_and_fail_check); 352 ATF_ADD_TEST_CASE(tcs, expect_fail_but_pass); 353 ATF_ADD_TEST_CASE(tcs, expect_exit_any_and_exit); 354 ATF_ADD_TEST_CASE(tcs, expect_exit_code_and_exit); 355 ATF_ADD_TEST_CASE(tcs, expect_exit_but_pass); 356 ATF_ADD_TEST_CASE(tcs, expect_signal_any_and_signal); 357 ATF_ADD_TEST_CASE(tcs, expect_signal_no_and_signal); 358 ATF_ADD_TEST_CASE(tcs, expect_signal_but_pass); 359 ATF_ADD_TEST_CASE(tcs, expect_death_and_exit); 360 ATF_ADD_TEST_CASE(tcs, expect_death_and_signal); 361 ATF_ADD_TEST_CASE(tcs, expect_death_but_pass); 362 ATF_ADD_TEST_CASE(tcs, expect_timeout_and_hang); 363 ATF_ADD_TEST_CASE(tcs, expect_timeout_but_pass); 364 365 // Add helper tests for t_fork. 366 ATF_ADD_TEST_CASE(tcs, fork_stop); 367 368 // Add helper tests for t_meta_data. 369 ATF_ADD_TEST_CASE(tcs, metadata_no_descr); 370 ATF_ADD_TEST_CASE(tcs, metadata_no_head); 371 372 // Add helper tests for t_srcdir. 373 ATF_ADD_TEST_CASE(tcs, srcdir_exists); 374 375 // Add helper tests for t_result. 376 ATF_ADD_TEST_CASE(tcs, result_pass); 377 ATF_ADD_TEST_CASE(tcs, result_fail); 378 ATF_ADD_TEST_CASE(tcs, result_skip); 379 ATF_ADD_TEST_CASE(tcs, result_newlines_fail); 380 ATF_ADD_TEST_CASE(tcs, result_newlines_skip); 381 ATF_ADD_TEST_CASE(tcs, result_exception); 382 } 383