1 // Copyright (c) 2008 The NetBSD Foundation, Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions
6 // are met:
7 // 1. Redistributions of source code must retain the above copyright
8 // notice, this list of conditions and the following disclaimer.
9 // 2. Redistributions in binary form must reproduce the above copyright
10 // notice, this list of conditions and the following disclaimer in the
11 // documentation and/or other materials provided with the distribution.
12 //
13 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
14 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
15 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
16 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
18 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
20 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
22 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
24 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25
26 #include "atf-c++/macros.hpp"
27
28 extern "C" {
29 #include <fcntl.h>
30 #include <unistd.h>
31 }
32
33 #include <cerrno>
34 #include <cstdlib>
35 #include <iostream>
36 #include <stdexcept>
37
38 #include <atf-c++.hpp>
39
40 #include "atf-c++/detail/fs.hpp"
41 #include "atf-c++/detail/process.hpp"
42 #include "atf-c++/detail/sanity.hpp"
43 #include "atf-c++/detail/test_helpers.hpp"
44 #include "atf-c++/detail/text.hpp"
45 #include "atf-c++/utils.hpp"
46
47 // ------------------------------------------------------------------------
48 // Auxiliary functions.
49 // ------------------------------------------------------------------------
50
51 static
52 void
create_ctl_file(const char * name)53 create_ctl_file(const char *name)
54 {
55 ATF_REQUIRE(open(name, O_CREAT | O_WRONLY | O_TRUNC, 0644) != -1);
56 }
57
58 // ------------------------------------------------------------------------
59 // Auxiliary test cases.
60 // ------------------------------------------------------------------------
61
62 ATF_TEST_CASE(h_pass);
ATF_TEST_CASE_HEAD(h_pass)63 ATF_TEST_CASE_HEAD(h_pass)
64 {
65 set_md_var("descr", "Helper test case");
66 }
ATF_TEST_CASE_BODY(h_pass)67 ATF_TEST_CASE_BODY(h_pass)
68 {
69 create_ctl_file("before");
70 ATF_PASS();
71 create_ctl_file("after");
72 }
73
74 ATF_TEST_CASE(h_fail);
ATF_TEST_CASE_HEAD(h_fail)75 ATF_TEST_CASE_HEAD(h_fail)
76 {
77 set_md_var("descr", "Helper test case");
78 }
ATF_TEST_CASE_BODY(h_fail)79 ATF_TEST_CASE_BODY(h_fail)
80 {
81 create_ctl_file("before");
82 ATF_FAIL("Failed on purpose");
83 create_ctl_file("after");
84 }
85
86 ATF_TEST_CASE(h_skip);
ATF_TEST_CASE_HEAD(h_skip)87 ATF_TEST_CASE_HEAD(h_skip)
88 {
89 set_md_var("descr", "Helper test case");
90 }
ATF_TEST_CASE_BODY(h_skip)91 ATF_TEST_CASE_BODY(h_skip)
92 {
93 create_ctl_file("before");
94 ATF_SKIP("Skipped on purpose");
95 create_ctl_file("after");
96 }
97
98 ATF_TEST_CASE(h_require);
ATF_TEST_CASE_HEAD(h_require)99 ATF_TEST_CASE_HEAD(h_require)
100 {
101 set_md_var("descr", "Helper test case");
102 }
ATF_TEST_CASE_BODY(h_require)103 ATF_TEST_CASE_BODY(h_require)
104 {
105 bool condition = atf::text::to_bool(get_config_var("condition"));
106
107 create_ctl_file("before");
108 ATF_REQUIRE(condition);
109 create_ctl_file("after");
110 }
111
112 ATF_TEST_CASE(h_require_eq);
ATF_TEST_CASE_HEAD(h_require_eq)113 ATF_TEST_CASE_HEAD(h_require_eq)
114 {
115 set_md_var("descr", "Helper test case");
116 }
ATF_TEST_CASE_BODY(h_require_eq)117 ATF_TEST_CASE_BODY(h_require_eq)
118 {
119 long v1 = atf::text::to_type< long >(get_config_var("v1"));
120 long v2 = atf::text::to_type< long >(get_config_var("v2"));
121
122 create_ctl_file("before");
123 ATF_REQUIRE_EQ(v1, v2);
124 create_ctl_file("after");
125 }
126
127 ATF_TEST_CASE(h_require_in);
ATF_TEST_CASE_HEAD(h_require_in)128 ATF_TEST_CASE_HEAD(h_require_in)
129 {
130 set_md_var("descr", "Helper test case");
131 }
ATF_TEST_CASE_BODY(h_require_in)132 ATF_TEST_CASE_BODY(h_require_in)
133 {
134 const std::string element = get_config_var("value");
135
136 std::set< std::string > collection;
137 collection.insert("foo");
138 collection.insert("bar");
139 collection.insert("baz");
140
141 create_ctl_file("before");
142 ATF_REQUIRE_IN(element, collection);
143 create_ctl_file("after");
144 }
145
146 ATF_TEST_CASE(h_require_match);
ATF_TEST_CASE_HEAD(h_require_match)147 ATF_TEST_CASE_HEAD(h_require_match)
148 {
149 set_md_var("descr", "Helper test case");
150 }
ATF_TEST_CASE_BODY(h_require_match)151 ATF_TEST_CASE_BODY(h_require_match)
152 {
153 const std::string regexp = get_config_var("regexp");
154 const std::string string = get_config_var("string");
155
156 create_ctl_file("before");
157 ATF_REQUIRE_MATCH(regexp, string);
158 create_ctl_file("after");
159 }
160
161 ATF_TEST_CASE(h_require_not_in);
ATF_TEST_CASE_HEAD(h_require_not_in)162 ATF_TEST_CASE_HEAD(h_require_not_in)
163 {
164 set_md_var("descr", "Helper test case");
165 }
ATF_TEST_CASE_BODY(h_require_not_in)166 ATF_TEST_CASE_BODY(h_require_not_in)
167 {
168 const std::string element = get_config_var("value");
169
170 std::set< std::string > collection;
171 collection.insert("foo");
172 collection.insert("bar");
173 collection.insert("baz");
174
175 create_ctl_file("before");
176 ATF_REQUIRE_NOT_IN(element, collection);
177 create_ctl_file("after");
178 }
179
180 ATF_TEST_CASE(h_require_throw);
ATF_TEST_CASE_HEAD(h_require_throw)181 ATF_TEST_CASE_HEAD(h_require_throw)
182 {
183 set_md_var("descr", "Helper test case");
184 }
ATF_TEST_CASE_BODY(h_require_throw)185 ATF_TEST_CASE_BODY(h_require_throw)
186 {
187 create_ctl_file("before");
188
189 if (get_config_var("what") == "throw_int")
190 ATF_REQUIRE_THROW(std::runtime_error, if (1) throw int(5));
191 else if (get_config_var("what") == "throw_rt")
192 ATF_REQUIRE_THROW(std::runtime_error,
193 if (1) throw std::runtime_error("e"));
194 else if (get_config_var("what") == "no_throw_rt")
195 ATF_REQUIRE_THROW(std::runtime_error,
196 if (0) throw std::runtime_error("e"));
197
198 create_ctl_file("after");
199 }
200
201 ATF_TEST_CASE(h_require_throw_re);
ATF_TEST_CASE_HEAD(h_require_throw_re)202 ATF_TEST_CASE_HEAD(h_require_throw_re)
203 {
204 set_md_var("descr", "Helper test case");
205 }
ATF_TEST_CASE_BODY(h_require_throw_re)206 ATF_TEST_CASE_BODY(h_require_throw_re)
207 {
208 create_ctl_file("before");
209
210 if (get_config_var("what") == "throw_int")
211 ATF_REQUIRE_THROW_RE(std::runtime_error, "5", if (1) throw int(5));
212 else if (get_config_var("what") == "throw_rt_match")
213 ATF_REQUIRE_THROW_RE(std::runtime_error, "foo.*baz",
214 if (1) throw std::runtime_error("a foo bar baz"));
215 else if (get_config_var("what") == "throw_rt_no_match")
216 ATF_REQUIRE_THROW_RE(std::runtime_error, "foo.*baz",
217 if (1) throw std::runtime_error("baz foo bar a"));
218 else if (get_config_var("what") == "no_throw_rt")
219 ATF_REQUIRE_THROW_RE(std::runtime_error, "e",
220 if (0) throw std::runtime_error("e"));
221
222 create_ctl_file("after");
223 }
224
225 static int
errno_fail_stub(const int raised_errno)226 errno_fail_stub(const int raised_errno)
227 {
228 errno = raised_errno;
229 return -1;
230 }
231
232 static int
errno_ok_stub(void)233 errno_ok_stub(void)
234 {
235 return 0;
236 }
237
238 ATF_TEST_CASE(h_check_errno);
ATF_TEST_CASE_HEAD(h_check_errno)239 ATF_TEST_CASE_HEAD(h_check_errno)
240 {
241 set_md_var("descr", "Helper test case");
242 }
ATF_TEST_CASE_BODY(h_check_errno)243 ATF_TEST_CASE_BODY(h_check_errno)
244 {
245 create_ctl_file("before");
246
247 if (get_config_var("what") == "no_error")
248 ATF_CHECK_ERRNO(-1, errno_ok_stub() == -1);
249 else if (get_config_var("what") == "errno_ok")
250 ATF_CHECK_ERRNO(2, errno_fail_stub(2) == -1);
251 else if (get_config_var("what") == "errno_fail")
252 ATF_CHECK_ERRNO(3, errno_fail_stub(4) == -1);
253 else
254 UNREACHABLE;
255
256 create_ctl_file("after");
257 }
258
259 ATF_TEST_CASE(h_require_errno);
ATF_TEST_CASE_HEAD(h_require_errno)260 ATF_TEST_CASE_HEAD(h_require_errno)
261 {
262 set_md_var("descr", "Helper test case");
263 }
ATF_TEST_CASE_BODY(h_require_errno)264 ATF_TEST_CASE_BODY(h_require_errno)
265 {
266 create_ctl_file("before");
267
268 if (get_config_var("what") == "no_error")
269 ATF_REQUIRE_ERRNO(-1, errno_ok_stub() == -1);
270 else if (get_config_var("what") == "errno_ok")
271 ATF_REQUIRE_ERRNO(2, errno_fail_stub(2) == -1);
272 else if (get_config_var("what") == "errno_fail")
273 ATF_REQUIRE_ERRNO(3, errno_fail_stub(4) == -1);
274 else
275 UNREACHABLE;
276
277 create_ctl_file("after");
278 }
279
280 // ------------------------------------------------------------------------
281 // Test cases for the macros.
282 // ------------------------------------------------------------------------
283
284 ATF_TEST_CASE(pass);
ATF_TEST_CASE_HEAD(pass)285 ATF_TEST_CASE_HEAD(pass)
286 {
287 set_md_var("descr", "Tests the ATF_PASS macro");
288 }
ATF_TEST_CASE_BODY(pass)289 ATF_TEST_CASE_BODY(pass)
290 {
291 ATF_TEST_CASE_USE(h_pass);
292 run_h_tc< ATF_TEST_CASE_NAME(h_pass) >();
293 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
294 ATF_REQUIRE(atf::fs::exists(atf::fs::path("before")));
295 ATF_REQUIRE(!atf::fs::exists(atf::fs::path("after")));
296 }
297
298 ATF_TEST_CASE(fail);
ATF_TEST_CASE_HEAD(fail)299 ATF_TEST_CASE_HEAD(fail)
300 {
301 set_md_var("descr", "Tests the ATF_FAIL macro");
302 }
ATF_TEST_CASE_BODY(fail)303 ATF_TEST_CASE_BODY(fail)
304 {
305 ATF_TEST_CASE_USE(h_fail);
306 run_h_tc< ATF_TEST_CASE_NAME(h_fail) >();
307 ATF_REQUIRE(atf::utils::grep_file("^failed: Failed on purpose", "result"));
308 ATF_REQUIRE(atf::fs::exists(atf::fs::path("before")));
309 ATF_REQUIRE(!atf::fs::exists(atf::fs::path("after")));
310 }
311
312 ATF_TEST_CASE(skip);
ATF_TEST_CASE_HEAD(skip)313 ATF_TEST_CASE_HEAD(skip)
314 {
315 set_md_var("descr", "Tests the ATF_SKIP macro");
316 }
ATF_TEST_CASE_BODY(skip)317 ATF_TEST_CASE_BODY(skip)
318 {
319 ATF_TEST_CASE_USE(h_skip);
320 run_h_tc< ATF_TEST_CASE_NAME(h_skip) >();
321 ATF_REQUIRE(atf::utils::grep_file("^skipped: Skipped on purpose",
322 "result"));
323 ATF_REQUIRE(atf::fs::exists(atf::fs::path("before")));
324 ATF_REQUIRE(!atf::fs::exists(atf::fs::path("after")));
325 }
326
327 ATF_TEST_CASE(require);
ATF_TEST_CASE_HEAD(require)328 ATF_TEST_CASE_HEAD(require)
329 {
330 set_md_var("descr", "Tests the ATF_REQUIRE macro");
331 }
ATF_TEST_CASE_BODY(require)332 ATF_TEST_CASE_BODY(require)
333 {
334 struct test {
335 const char *cond;
336 bool ok;
337 } *t, tests[] = {
338 { "false", false },
339 { "true", true },
340 { NULL, false }
341 };
342
343 const atf::fs::path before("before");
344 const atf::fs::path after("after");
345
346 for (t = &tests[0]; t->cond != NULL; t++) {
347 atf::tests::vars_map config;
348 config["condition"] = t->cond;
349
350 std::cout << "Checking with a " << t->cond << " value\n";
351
352 ATF_TEST_CASE_USE(h_require);
353 run_h_tc< ATF_TEST_CASE_NAME(h_require) >(config);
354
355 ATF_REQUIRE(atf::fs::exists(before));
356 if (t->ok) {
357 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
358 ATF_REQUIRE(atf::fs::exists(after));
359 } else {
360 ATF_REQUIRE(atf::utils::grep_file(
361 "^failed: .*condition not met", "result"));
362 ATF_REQUIRE(!atf::fs::exists(after));
363 }
364
365 atf::fs::remove(before);
366 if (t->ok)
367 atf::fs::remove(after);
368 }
369 }
370
371 ATF_TEST_CASE(require_eq);
ATF_TEST_CASE_HEAD(require_eq)372 ATF_TEST_CASE_HEAD(require_eq)
373 {
374 set_md_var("descr", "Tests the ATF_REQUIRE_EQ macro");
375 }
ATF_TEST_CASE_BODY(require_eq)376 ATF_TEST_CASE_BODY(require_eq)
377 {
378 struct test {
379 const char *v1;
380 const char *v2;
381 bool ok;
382 } *t, tests[] = {
383 { "1", "1", true },
384 { "1", "2", false },
385 { "2", "1", false },
386 { "2", "2", true },
387 { NULL, NULL, false }
388 };
389
390 const atf::fs::path before("before");
391 const atf::fs::path after("after");
392
393 for (t = &tests[0]; t->v1 != NULL; t++) {
394 atf::tests::vars_map config;
395 config["v1"] = t->v1;
396 config["v2"] = t->v2;
397
398 std::cout << "Checking with " << t->v1 << ", " << t->v2
399 << " and expecting " << (t->ok ? "true" : "false")
400 << "\n";
401
402 ATF_TEST_CASE_USE(h_require_eq);
403 run_h_tc< ATF_TEST_CASE_NAME(h_require_eq) >(config);
404
405 ATF_REQUIRE(atf::fs::exists(before));
406 if (t->ok) {
407 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
408 ATF_REQUIRE(atf::fs::exists(after));
409 } else {
410 ATF_REQUIRE(atf::utils::grep_file("^failed: .*v1 != v2", "result"));
411 ATF_REQUIRE(!atf::fs::exists(after));
412 }
413
414 atf::fs::remove(before);
415 if (t->ok)
416 atf::fs::remove(after);
417 }
418 }
419
420 ATF_TEST_CASE(require_in);
ATF_TEST_CASE_HEAD(require_in)421 ATF_TEST_CASE_HEAD(require_in)
422 {
423 set_md_var("descr", "Tests the ATF_REQUIRE_IN macro");
424 }
ATF_TEST_CASE_BODY(require_in)425 ATF_TEST_CASE_BODY(require_in)
426 {
427 struct test {
428 const char *value;
429 bool ok;
430 } *t, tests[] = {
431 { "foo", true },
432 { "bar", true },
433 { "baz", true },
434 { "xxx", false },
435 { "fooa", false },
436 { "foo ", false },
437 { NULL, false }
438 };
439
440 const atf::fs::path before("before");
441 const atf::fs::path after("after");
442
443 for (t = &tests[0]; t->value != NULL; t++) {
444 atf::tests::vars_map config;
445 config["value"] = t->value;
446
447 ATF_TEST_CASE_USE(h_require_in);
448 run_h_tc< ATF_TEST_CASE_NAME(h_require_in) >(config);
449
450 ATF_REQUIRE(atf::fs::exists(before));
451 if (t->ok) {
452 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
453 ATF_REQUIRE(atf::fs::exists(after));
454 } else {
455 ATF_REQUIRE(atf::utils::grep_file("^failed: ", "result"));
456 ATF_REQUIRE(!atf::fs::exists(after));
457 }
458
459 atf::fs::remove(before);
460 if (t->ok)
461 atf::fs::remove(after);
462 }
463 }
464
465 ATF_TEST_CASE(require_match);
ATF_TEST_CASE_HEAD(require_match)466 ATF_TEST_CASE_HEAD(require_match)
467 {
468 set_md_var("descr", "Tests the ATF_REQUIRE_MATCH macro");
469 }
ATF_TEST_CASE_BODY(require_match)470 ATF_TEST_CASE_BODY(require_match)
471 {
472 struct test {
473 const char *regexp;
474 const char *string;
475 bool ok;
476 } *t, tests[] = {
477 { "foo.*bar", "this is a foo, bar, baz", true },
478 { "bar.*baz", "this is a baz, bar, foo", false },
479 { NULL, NULL, false }
480 };
481
482 const atf::fs::path before("before");
483 const atf::fs::path after("after");
484
485 for (t = &tests[0]; t->regexp != NULL; t++) {
486 atf::tests::vars_map config;
487 config["regexp"] = t->regexp;
488 config["string"] = t->string;
489
490 std::cout << "Checking with " << t->regexp << ", " << t->string
491 << " and expecting " << (t->ok ? "true" : "false")
492 << "\n";
493
494 ATF_TEST_CASE_USE(h_require_match);
495 run_h_tc< ATF_TEST_CASE_NAME(h_require_match) >(config);
496
497 ATF_REQUIRE(atf::fs::exists(before));
498 if (t->ok) {
499 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
500 ATF_REQUIRE(atf::fs::exists(after));
501 } else {
502 ATF_REQUIRE(atf::utils::grep_file("^failed: ", "result"));
503 ATF_REQUIRE(!atf::fs::exists(after));
504 }
505
506 atf::fs::remove(before);
507 if (t->ok)
508 atf::fs::remove(after);
509 }
510 }
511
512 ATF_TEST_CASE(require_not_in);
ATF_TEST_CASE_HEAD(require_not_in)513 ATF_TEST_CASE_HEAD(require_not_in)
514 {
515 set_md_var("descr", "Tests the ATF_REQUIRE_NOT_IN macro");
516 }
ATF_TEST_CASE_BODY(require_not_in)517 ATF_TEST_CASE_BODY(require_not_in)
518 {
519 struct test {
520 const char *value;
521 bool ok;
522 } *t, tests[] = {
523 { "foo", false },
524 { "bar", false },
525 { "baz", false },
526 { "xxx", true },
527 { "fooa", true },
528 { "foo ", true },
529 { NULL, false }
530 };
531
532 const atf::fs::path before("before");
533 const atf::fs::path after("after");
534
535 for (t = &tests[0]; t->value != NULL; t++) {
536 atf::tests::vars_map config;
537 config["value"] = t->value;
538
539 ATF_TEST_CASE_USE(h_require_not_in);
540 run_h_tc< ATF_TEST_CASE_NAME(h_require_not_in) >(config);
541
542 ATF_REQUIRE(atf::fs::exists(before));
543 if (t->ok) {
544 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
545 ATF_REQUIRE(atf::fs::exists(after));
546 } else {
547 ATF_REQUIRE(atf::utils::grep_file("^failed: ", "result"));
548 ATF_REQUIRE(!atf::fs::exists(after));
549 }
550
551 atf::fs::remove(before);
552 if (t->ok)
553 atf::fs::remove(after);
554 }
555 }
556
557 ATF_TEST_CASE(require_throw);
ATF_TEST_CASE_HEAD(require_throw)558 ATF_TEST_CASE_HEAD(require_throw)
559 {
560 set_md_var("descr", "Tests the ATF_REQUIRE_THROW macro");
561 }
ATF_TEST_CASE_BODY(require_throw)562 ATF_TEST_CASE_BODY(require_throw)
563 {
564 struct test {
565 const char *what;
566 bool ok;
567 const char *msg;
568 } *t, tests[] = {
569 { "throw_int", false, "unexpected error" },
570 { "throw_rt", true, NULL },
571 { "no_throw_rt", false, "did not throw" },
572 { NULL, false, NULL }
573 };
574
575 const atf::fs::path before("before");
576 const atf::fs::path after("after");
577
578 for (t = &tests[0]; t->what != NULL; t++) {
579 atf::tests::vars_map config;
580 config["what"] = t->what;
581
582 std::cout << "Checking with " << t->what << " and expecting "
583 << (t->ok ? "true" : "false") << "\n";
584
585 ATF_TEST_CASE_USE(h_require_throw);
586 run_h_tc< ATF_TEST_CASE_NAME(h_require_throw) >(config);
587
588 ATF_REQUIRE(atf::fs::exists(before));
589 if (t->ok) {
590 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
591 ATF_REQUIRE(atf::fs::exists(after));
592 } else {
593 std::cout << "Checking that message contains '" << t->msg
594 << "'\n";
595 std::string exp_result = std::string("^failed: .*") + t->msg;
596 ATF_REQUIRE(atf::utils::grep_file(exp_result.c_str(), "result"));
597 ATF_REQUIRE(!atf::fs::exists(after));
598 }
599
600 atf::fs::remove(before);
601 if (t->ok)
602 atf::fs::remove(after);
603 }
604 }
605
606 ATF_TEST_CASE(require_throw_re);
ATF_TEST_CASE_HEAD(require_throw_re)607 ATF_TEST_CASE_HEAD(require_throw_re)
608 {
609 set_md_var("descr", "Tests the ATF_REQUIRE_THROW_RE macro");
610 }
ATF_TEST_CASE_BODY(require_throw_re)611 ATF_TEST_CASE_BODY(require_throw_re)
612 {
613 struct test {
614 const char *what;
615 bool ok;
616 const char *msg;
617 } *t, tests[] = {
618 { "throw_int", false, "unexpected error" },
619 { "throw_rt_match", true, NULL },
620 { "throw_rt_no_match", false,
621 "threw.*runtime_error\\(baz foo bar a\\).*"
622 "does not match 'foo\\.\\*baz'" },
623 { "no_throw_rt", false, "did not throw" },
624 { NULL, false, NULL }
625 };
626
627 const atf::fs::path before("before");
628 const atf::fs::path after("after");
629
630 for (t = &tests[0]; t->what != NULL; t++) {
631 atf::tests::vars_map config;
632 config["what"] = t->what;
633
634 std::cout << "Checking with " << t->what << " and expecting "
635 << (t->ok ? "true" : "false") << "\n";
636
637 ATF_TEST_CASE_USE(h_require_throw_re);
638 run_h_tc< ATF_TEST_CASE_NAME(h_require_throw_re) >(config);
639
640 ATF_REQUIRE(atf::fs::exists(before));
641 if (t->ok) {
642 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
643 ATF_REQUIRE(atf::fs::exists(after));
644 } else {
645 std::cout << "Checking that message contains '" << t->msg
646 << "'\n";
647 std::string exp_result = std::string("^failed: .*") + t->msg;
648 ATF_REQUIRE(atf::utils::grep_file(exp_result.c_str(), "result"));
649 ATF_REQUIRE(!atf::fs::exists(after));
650 }
651
652 atf::fs::remove(before);
653 if (t->ok)
654 atf::fs::remove(after);
655 }
656 }
657
658 ATF_TEST_CASE(check_errno);
ATF_TEST_CASE_HEAD(check_errno)659 ATF_TEST_CASE_HEAD(check_errno)
660 {
661 set_md_var("descr", "Tests the ATF_CHECK_ERRNO macro");
662 }
ATF_TEST_CASE_BODY(check_errno)663 ATF_TEST_CASE_BODY(check_errno)
664 {
665 struct test {
666 const char *what;
667 bool ok;
668 const char *msg;
669 } *t, tests[] = {
670 { "no_error", false,
671 "Expected true value in errno_ok_stub\\(\\) == -1" },
672 { "errno_ok", true, NULL },
673 { "errno_fail", false,
674 "Expected errno 3, got 4, in errno_fail_stub\\(4\\) == -1" },
675 { NULL, false, NULL }
676 };
677
678 const atf::fs::path before("before");
679 const atf::fs::path after("after");
680
681 for (t = &tests[0]; t->what != NULL; t++) {
682 atf::tests::vars_map config;
683 config["what"] = t->what;
684
685 ATF_TEST_CASE_USE(h_check_errno);
686 run_h_tc< ATF_TEST_CASE_NAME(h_check_errno) >(config);
687
688 ATF_REQUIRE(atf::fs::exists(before));
689 ATF_REQUIRE(atf::fs::exists(after));
690
691 if (t->ok) {
692 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
693 } else {
694 ATF_REQUIRE(atf::utils::grep_file("^failed", "result"));
695
696 std::string exp_result = "macros_test.cpp:[0-9]+: " +
697 std::string(t->msg) + "$";
698 ATF_REQUIRE(atf::utils::grep_file(exp_result.c_str(), "stderr"));
699 }
700
701 atf::fs::remove(before);
702 atf::fs::remove(after);
703 }
704 }
705
706 ATF_TEST_CASE(require_errno);
ATF_TEST_CASE_HEAD(require_errno)707 ATF_TEST_CASE_HEAD(require_errno)
708 {
709 set_md_var("descr", "Tests the ATF_REQUIRE_ERRNO macro");
710 }
ATF_TEST_CASE_BODY(require_errno)711 ATF_TEST_CASE_BODY(require_errno)
712 {
713 struct test {
714 const char *what;
715 bool ok;
716 const char *msg;
717 } *t, tests[] = {
718 { "no_error", false,
719 "Expected true value in errno_ok_stub\\(\\) == -1" },
720 { "errno_ok", true, NULL },
721 { "errno_fail", false,
722 "Expected errno 3, got 4, in errno_fail_stub\\(4\\) == -1" },
723 { NULL, false, NULL }
724 };
725
726 const atf::fs::path before("before");
727 const atf::fs::path after("after");
728
729 for (t = &tests[0]; t->what != NULL; t++) {
730 atf::tests::vars_map config;
731 config["what"] = t->what;
732
733 ATF_TEST_CASE_USE(h_require_errno);
734 run_h_tc< ATF_TEST_CASE_NAME(h_require_errno) >(config);
735
736 ATF_REQUIRE(atf::fs::exists(before));
737 if (t->ok) {
738 ATF_REQUIRE(atf::utils::grep_file("^passed", "result"));
739 ATF_REQUIRE(atf::fs::exists(after));
740 } else {
741 std::string exp_result = "^failed: .*macros_test.cpp:[0-9]+: " +
742 std::string(t->msg) + "$";
743 ATF_REQUIRE(atf::utils::grep_file(exp_result.c_str(), "result"));
744
745 ATF_REQUIRE(!atf::fs::exists(after));
746 }
747
748 atf::fs::remove(before);
749 if (t->ok)
750 atf::fs::remove(after);
751 }
752 }
753
754 // ------------------------------------------------------------------------
755 // Tests cases for the header file.
756 // ------------------------------------------------------------------------
757
758 BUILD_TC(use, "macros_hpp_test.cpp",
759 "Tests that the macros provided by the atf-c++/macros.hpp file "
760 "do not cause syntax errors when used",
761 "Build of macros_hpp_test.cpp failed; some macros in "
762 "atf-c++/macros.hpp are broken");
763
764 ATF_TEST_CASE(detect_unused_tests);
ATF_TEST_CASE_HEAD(detect_unused_tests)765 ATF_TEST_CASE_HEAD(detect_unused_tests)
766 {
767 set_md_var("descr",
768 "Tests that defining an unused test case raises a warning (and "
769 "thus an error)");
770 }
ATF_TEST_CASE_BODY(detect_unused_tests)771 ATF_TEST_CASE_BODY(detect_unused_tests)
772 {
773 const char* validate_compiler =
774 "class test_class { public: int dummy; };\n"
775 "#define define_unused static test_class unused\n"
776 "define_unused;\n";
777
778 atf::utils::create_file("compiler_test.cpp", validate_compiler);
779 if (build_check_cxx_o("compiler_test.cpp"))
780 expect_fail("Compiler does not raise a warning on an unused "
781 "static global variable declared by a macro");
782
783 if (build_check_cxx_o_srcdir(*this, "unused_test.cpp"))
784 ATF_FAIL("Build of unused_test.cpp passed; unused test cases are "
785 "not properly detected");
786 }
787
788 // ------------------------------------------------------------------------
789 // Main.
790 // ------------------------------------------------------------------------
791
ATF_INIT_TEST_CASES(tcs)792 ATF_INIT_TEST_CASES(tcs)
793 {
794 // Add the test cases for the macros.
795 ATF_ADD_TEST_CASE(tcs, pass);
796 ATF_ADD_TEST_CASE(tcs, fail);
797 ATF_ADD_TEST_CASE(tcs, skip);
798 ATF_ADD_TEST_CASE(tcs, check_errno);
799 ATF_ADD_TEST_CASE(tcs, require);
800 ATF_ADD_TEST_CASE(tcs, require_eq);
801 ATF_ADD_TEST_CASE(tcs, require_in);
802 ATF_ADD_TEST_CASE(tcs, require_match);
803 ATF_ADD_TEST_CASE(tcs, require_not_in);
804 ATF_ADD_TEST_CASE(tcs, require_throw);
805 ATF_ADD_TEST_CASE(tcs, require_throw_re);
806 ATF_ADD_TEST_CASE(tcs, require_errno);
807
808 // Add the test cases for the header file.
809 ATF_ADD_TEST_CASE(tcs, use);
810 ATF_ADD_TEST_CASE(tcs, detect_unused_tests);
811 }
812