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