1 // 2 // Automated Testing Framework (atf) 3 // 4 // Copyright (c) 2007 The NetBSD Foundation, Inc. 5 // All rights reserved. 6 // 7 // Redistribution and use in source and binary forms, with or without 8 // modification, are permitted provided that the following conditions 9 // are met: 10 // 1. Redistributions of source code must retain the above copyright 11 // notice, this list of conditions and the following disclaimer. 12 // 2. Redistributions in binary form must reproduce the above copyright 13 // notice, this list of conditions and the following disclaimer in the 14 // documentation and/or other materials provided with the distribution. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 // 29 30 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++.hpp> 40 41 #include "atf-c++/detail/fs.hpp" 42 43 // ------------------------------------------------------------------------ 44 // Helper tests for "t_config". 45 // ------------------------------------------------------------------------ 46 47 ATF_TEST_CASE(config_unset); 48 ATF_TEST_CASE_HEAD(config_unset) 49 { 50 set_md_var("descr", "Helper test case for the t_config test program"); 51 } 52 ATF_TEST_CASE_BODY(config_unset) 53 { 54 ATF_REQUIRE(!has_config_var("test")); 55 } 56 57 ATF_TEST_CASE(config_empty); 58 ATF_TEST_CASE_HEAD(config_empty) 59 { 60 set_md_var("descr", "Helper test case for the t_config test program"); 61 } 62 ATF_TEST_CASE_BODY(config_empty) 63 { 64 ATF_REQUIRE_EQ(get_config_var("test"), ""); 65 } 66 67 ATF_TEST_CASE(config_value); 68 ATF_TEST_CASE_HEAD(config_value) 69 { 70 set_md_var("descr", "Helper test case for the t_config test program"); 71 } 72 ATF_TEST_CASE_BODY(config_value) 73 { 74 ATF_REQUIRE_EQ(get_config_var("test"), "foo"); 75 } 76 77 ATF_TEST_CASE(config_multi_value); 78 ATF_TEST_CASE_HEAD(config_multi_value) 79 { 80 set_md_var("descr", "Helper test case for the t_config test program"); 81 } 82 ATF_TEST_CASE_BODY(config_multi_value) 83 { 84 ATF_REQUIRE_EQ(get_config_var("test"), "foo bar"); 85 } 86 87 // ------------------------------------------------------------------------ 88 // Helper tests for "t_expect". 89 // ------------------------------------------------------------------------ 90 91 ATF_TEST_CASE_WITHOUT_HEAD(expect_pass_and_pass); 92 ATF_TEST_CASE_BODY(expect_pass_and_pass) 93 { 94 expect_pass(); 95 } 96 97 ATF_TEST_CASE_WITHOUT_HEAD(expect_pass_but_fail_requirement); 98 ATF_TEST_CASE_BODY(expect_pass_but_fail_requirement) 99 { 100 expect_pass(); 101 fail("Some reason"); 102 } 103 104 ATF_TEST_CASE_WITHOUT_HEAD(expect_pass_but_fail_check); 105 ATF_TEST_CASE_BODY(expect_pass_but_fail_check) 106 { 107 expect_pass(); 108 fail_nonfatal("Some reason"); 109 } 110 111 ATF_TEST_CASE_WITHOUT_HEAD(expect_fail_and_fail_requirement); 112 ATF_TEST_CASE_BODY(expect_fail_and_fail_requirement) 113 { 114 expect_fail("Fail reason"); 115 fail("The failure"); 116 expect_pass(); 117 } 118 119 ATF_TEST_CASE_WITHOUT_HEAD(expect_fail_and_fail_check); 120 ATF_TEST_CASE_BODY(expect_fail_and_fail_check) 121 { 122 expect_fail("Fail first"); 123 fail_nonfatal("abc"); 124 expect_pass(); 125 126 expect_fail("And fail again"); 127 fail_nonfatal("def"); 128 expect_pass(); 129 } 130 131 ATF_TEST_CASE_WITHOUT_HEAD(expect_fail_but_pass); 132 ATF_TEST_CASE_BODY(expect_fail_but_pass) 133 { 134 expect_fail("Fail first"); 135 fail_nonfatal("abc"); 136 expect_pass(); 137 138 expect_fail("Will not fail"); 139 expect_pass(); 140 141 expect_fail("And fail again"); 142 fail_nonfatal("def"); 143 expect_pass(); 144 } 145 146 ATF_TEST_CASE_WITHOUT_HEAD(expect_exit_any_and_exit); 147 ATF_TEST_CASE_BODY(expect_exit_any_and_exit) 148 { 149 expect_exit(-1, "Call will exit"); 150 std::exit(EXIT_SUCCESS); 151 } 152 153 ATF_TEST_CASE_WITHOUT_HEAD(expect_exit_code_and_exit); 154 ATF_TEST_CASE_BODY(expect_exit_code_and_exit) 155 { 156 expect_exit(123, "Call will exit"); 157 std::exit(123); 158 } 159 160 ATF_TEST_CASE_WITHOUT_HEAD(expect_exit_but_pass); 161 ATF_TEST_CASE_BODY(expect_exit_but_pass) 162 { 163 expect_exit(-1, "Call won't exit"); 164 } 165 166 ATF_TEST_CASE_WITHOUT_HEAD(expect_signal_any_and_signal); 167 ATF_TEST_CASE_BODY(expect_signal_any_and_signal) 168 { 169 expect_signal(-1, "Call will signal"); 170 ::kill(getpid(), SIGKILL); 171 } 172 173 ATF_TEST_CASE_WITHOUT_HEAD(expect_signal_no_and_signal); 174 ATF_TEST_CASE_BODY(expect_signal_no_and_signal) 175 { 176 expect_signal(SIGHUP, "Call will signal"); 177 ::kill(getpid(), SIGHUP); 178 } 179 180 ATF_TEST_CASE_WITHOUT_HEAD(expect_signal_but_pass); 181 ATF_TEST_CASE_BODY(expect_signal_but_pass) 182 { 183 expect_signal(-1, "Call won't signal"); 184 } 185 186 ATF_TEST_CASE_WITHOUT_HEAD(expect_death_and_exit); 187 ATF_TEST_CASE_BODY(expect_death_and_exit) 188 { 189 expect_death("Exit case"); 190 std::exit(123); 191 } 192 193 ATF_TEST_CASE_WITHOUT_HEAD(expect_death_and_signal); 194 ATF_TEST_CASE_BODY(expect_death_and_signal) 195 { 196 expect_death("Signal case"); 197 kill(getpid(), SIGKILL); 198 } 199 200 ATF_TEST_CASE_WITHOUT_HEAD(expect_death_but_pass); 201 ATF_TEST_CASE_BODY(expect_death_but_pass) 202 { 203 expect_death("Call won't die"); 204 } 205 206 ATF_TEST_CASE(expect_timeout_and_hang); 207 ATF_TEST_CASE_HEAD(expect_timeout_and_hang) 208 { 209 set_md_var("timeout", "1"); 210 } 211 ATF_TEST_CASE_BODY(expect_timeout_and_hang) 212 { 213 expect_timeout("Will overrun"); 214 ::sleep(5); 215 } 216 217 ATF_TEST_CASE(expect_timeout_but_pass); 218 ATF_TEST_CASE_HEAD(expect_timeout_but_pass) 219 { 220 set_md_var("timeout", "1"); 221 } 222 ATF_TEST_CASE_BODY(expect_timeout_but_pass) 223 { 224 expect_timeout("Will just exit"); 225 } 226 227 // ------------------------------------------------------------------------ 228 // Helper tests for "t_meta_data". 229 // ------------------------------------------------------------------------ 230 231 ATF_TEST_CASE(metadata_no_descr); 232 ATF_TEST_CASE_HEAD(metadata_no_descr) 233 { 234 } 235 ATF_TEST_CASE_BODY(metadata_no_descr) 236 { 237 } 238 239 ATF_TEST_CASE_WITHOUT_HEAD(metadata_no_head); 240 ATF_TEST_CASE_BODY(metadata_no_head) 241 { 242 } 243 244 // ------------------------------------------------------------------------ 245 // Helper tests for "t_srcdir". 246 // ------------------------------------------------------------------------ 247 248 ATF_TEST_CASE(srcdir_exists); 249 ATF_TEST_CASE_HEAD(srcdir_exists) 250 { 251 set_md_var("descr", "Helper test case for the t_srcdir test program"); 252 } 253 ATF_TEST_CASE_BODY(srcdir_exists) 254 { 255 if (!atf::fs::exists(atf::fs::path(get_config_var("srcdir")) / 256 "datafile")) 257 ATF_FAIL("Cannot find datafile"); 258 } 259 260 // ------------------------------------------------------------------------ 261 // Helper tests for "t_result". 262 // ------------------------------------------------------------------------ 263 264 ATF_TEST_CASE(result_pass); 265 ATF_TEST_CASE_HEAD(result_pass) { } 266 ATF_TEST_CASE_BODY(result_pass) 267 { 268 std::cout << "msg\n"; 269 } 270 271 ATF_TEST_CASE(result_fail); 272 ATF_TEST_CASE_HEAD(result_fail) { } 273 ATF_TEST_CASE_BODY(result_fail) 274 { 275 std::cout << "msg\n"; 276 ATF_FAIL("Failure reason"); 277 } 278 279 ATF_TEST_CASE(result_skip); 280 ATF_TEST_CASE_HEAD(result_skip) { } 281 ATF_TEST_CASE_BODY(result_skip) 282 { 283 std::cout << "msg\n"; 284 ATF_SKIP("Skipped reason"); 285 } 286 287 ATF_TEST_CASE(result_newlines_fail); 288 ATF_TEST_CASE_HEAD(result_newlines_fail) 289 { 290 set_md_var("descr", "Helper test case for the t_result test program"); 291 } 292 ATF_TEST_CASE_BODY(result_newlines_fail) 293 { 294 ATF_FAIL("First line\nSecond line"); 295 } 296 297 ATF_TEST_CASE(result_newlines_skip); 298 ATF_TEST_CASE_HEAD(result_newlines_skip) 299 { 300 set_md_var("descr", "Helper test case for the t_result test program"); 301 } 302 ATF_TEST_CASE_BODY(result_newlines_skip) 303 { 304 ATF_SKIP("First line\nSecond line"); 305 } 306 307 ATF_TEST_CASE(result_exception); 308 ATF_TEST_CASE_HEAD(result_exception) { } 309 ATF_TEST_CASE_BODY(result_exception) 310 { 311 throw std::runtime_error("This is unhandled"); 312 } 313 314 // ------------------------------------------------------------------------ 315 // Main. 316 // ------------------------------------------------------------------------ 317 318 ATF_INIT_TEST_CASES(tcs) 319 { 320 // Add helper tests for t_config. 321 ATF_ADD_TEST_CASE(tcs, config_unset); 322 ATF_ADD_TEST_CASE(tcs, config_empty); 323 ATF_ADD_TEST_CASE(tcs, config_value); 324 ATF_ADD_TEST_CASE(tcs, config_multi_value); 325 326 // Add helper tests for t_expect. 327 ATF_ADD_TEST_CASE(tcs, expect_pass_and_pass); 328 ATF_ADD_TEST_CASE(tcs, expect_pass_but_fail_requirement); 329 ATF_ADD_TEST_CASE(tcs, expect_pass_but_fail_check); 330 ATF_ADD_TEST_CASE(tcs, expect_fail_and_fail_requirement); 331 ATF_ADD_TEST_CASE(tcs, expect_fail_and_fail_check); 332 ATF_ADD_TEST_CASE(tcs, expect_fail_but_pass); 333 ATF_ADD_TEST_CASE(tcs, expect_exit_any_and_exit); 334 ATF_ADD_TEST_CASE(tcs, expect_exit_code_and_exit); 335 ATF_ADD_TEST_CASE(tcs, expect_exit_but_pass); 336 ATF_ADD_TEST_CASE(tcs, expect_signal_any_and_signal); 337 ATF_ADD_TEST_CASE(tcs, expect_signal_no_and_signal); 338 ATF_ADD_TEST_CASE(tcs, expect_signal_but_pass); 339 ATF_ADD_TEST_CASE(tcs, expect_death_and_exit); 340 ATF_ADD_TEST_CASE(tcs, expect_death_and_signal); 341 ATF_ADD_TEST_CASE(tcs, expect_death_but_pass); 342 ATF_ADD_TEST_CASE(tcs, expect_timeout_and_hang); 343 ATF_ADD_TEST_CASE(tcs, expect_timeout_but_pass); 344 345 // Add helper tests for t_meta_data. 346 ATF_ADD_TEST_CASE(tcs, metadata_no_descr); 347 ATF_ADD_TEST_CASE(tcs, metadata_no_head); 348 349 // Add helper tests for t_srcdir. 350 ATF_ADD_TEST_CASE(tcs, srcdir_exists); 351 352 // Add helper tests for t_result. 353 ATF_ADD_TEST_CASE(tcs, result_pass); 354 ATF_ADD_TEST_CASE(tcs, result_fail); 355 ATF_ADD_TEST_CASE(tcs, result_skip); 356 ATF_ADD_TEST_CASE(tcs, result_newlines_fail); 357 ATF_ADD_TEST_CASE(tcs, result_newlines_skip); 358 ATF_ADD_TEST_CASE(tcs, result_exception); 359 } 360