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#include <sys/types.h>
31#include <sys/wait.h>
32#include <fcntl.h>
33#include <unistd.h>
34
35#include <signal.h>
36#include <stdio.h>
37#include <stdlib.h>
38#include <string.h>
39
40#include <atf-c.h>
41
42#include "atf-c/error.h"
43
44#include "atf-c/detail/env.h"
45#include "atf-c/detail/fs.h"
46#include "atf-c/detail/test_helpers.h"
47#include "atf-c/detail/text.h"
48
49/* ---------------------------------------------------------------------
50 * Auxiliary functions.
51 * --------------------------------------------------------------------- */
52
53static
54void
55safe_remove(const char* path)
56{
57    if (unlink(path) == -1)
58        atf_tc_fail("unlink(2) of %s failed", path);
59}
60
61static
62void
63touch(const char *path)
64{
65    int fd;
66    fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, 0644);
67    if (fd == -1)
68        atf_tc_fail("Could not create file %s", path);
69    close(fd);
70}
71
72/* ---------------------------------------------------------------------
73 * Helper tests for "t_cleanup".
74 * --------------------------------------------------------------------- */
75
76ATF_TC_WITH_CLEANUP(cleanup_pass);
77ATF_TC_HEAD(cleanup_pass, tc)
78{
79    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test "
80               "program");
81}
82ATF_TC_BODY(cleanup_pass, tc)
83{
84    touch(atf_tc_get_config_var(tc, "tmpfile"));
85}
86ATF_TC_CLEANUP(cleanup_pass, tc)
87{
88    if (atf_tc_get_config_var_as_bool(tc, "cleanup"))
89        safe_remove(atf_tc_get_config_var(tc, "tmpfile"));
90}
91
92ATF_TC_WITH_CLEANUP(cleanup_fail);
93ATF_TC_HEAD(cleanup_fail, tc)
94{
95    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test "
96                      "program");
97}
98ATF_TC_BODY(cleanup_fail, tc)
99{
100    touch(atf_tc_get_config_var(tc, "tmpfile"));
101    atf_tc_fail("On purpose");
102}
103ATF_TC_CLEANUP(cleanup_fail, tc)
104{
105    if (atf_tc_get_config_var_as_bool(tc, "cleanup"))
106        safe_remove(atf_tc_get_config_var(tc, "tmpfile"));
107}
108
109ATF_TC_WITH_CLEANUP(cleanup_skip);
110ATF_TC_HEAD(cleanup_skip, tc)
111{
112    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test "
113                      "program");
114}
115ATF_TC_BODY(cleanup_skip, tc)
116{
117    touch(atf_tc_get_config_var(tc, "tmpfile"));
118    atf_tc_skip("On purpose");
119}
120ATF_TC_CLEANUP(cleanup_skip, tc)
121{
122    if (atf_tc_get_config_var_as_bool(tc, "cleanup"))
123        safe_remove(atf_tc_get_config_var(tc, "tmpfile"));
124}
125
126ATF_TC_WITH_CLEANUP(cleanup_curdir);
127ATF_TC_HEAD(cleanup_curdir, tc)
128{
129    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test "
130                      "program");
131}
132ATF_TC_BODY(cleanup_curdir, tc)
133{
134    FILE *f;
135
136    f = fopen("oldvalue", "w");
137    if (f == NULL)
138        atf_tc_fail("Failed to create oldvalue file");
139    fprintf(f, "1234");
140    fclose(f);
141}
142ATF_TC_CLEANUP(cleanup_curdir, tc)
143{
144    FILE *f;
145
146    f = fopen("oldvalue", "r");
147    if (f != NULL) {
148        int i;
149        if (fscanf(f, "%d", &i) != 1)
150            fprintf(stderr, "Failed to read old value\n");
151        else
152            printf("Old value: %d", i);
153        fclose(f);
154    }
155}
156
157ATF_TC_WITH_CLEANUP(cleanup_sigterm);
158ATF_TC_HEAD(cleanup_sigterm, tc)
159{
160    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test "
161                      "program");
162}
163ATF_TC_BODY(cleanup_sigterm, tc)
164{
165    char *nofile;
166
167    touch(atf_tc_get_config_var(tc, "tmpfile"));
168    kill(getpid(), SIGTERM);
169
170    RE(atf_text_format(&nofile, "%s.no",
171                       atf_tc_get_config_var(tc, "tmpfile")));
172    touch(nofile);
173    free(nofile);
174}
175ATF_TC_CLEANUP(cleanup_sigterm, tc)
176{
177    safe_remove(atf_tc_get_config_var(tc, "tmpfile"));
178}
179
180ATF_TC_WITH_CLEANUP(cleanup_fork);
181ATF_TC_HEAD(cleanup_fork, tc)
182{
183    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_cleanup test "
184                      "program");
185}
186ATF_TC_BODY(cleanup_fork, tc)
187{
188}
189ATF_TC_CLEANUP(cleanup_fork, tc)
190{
191    close(STDOUT_FILENO);
192    close(STDERR_FILENO);
193    close(3);
194}
195
196/* ---------------------------------------------------------------------
197 * Helper tests for "t_config".
198 * --------------------------------------------------------------------- */
199
200ATF_TC(config_unset);
201ATF_TC_HEAD(config_unset, tc)
202{
203    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_config test "
204                      "program");
205}
206ATF_TC_BODY(config_unset, tc)
207{
208    ATF_REQUIRE(!atf_tc_has_config_var(tc, "test"));
209}
210
211ATF_TC(config_empty);
212ATF_TC_HEAD(config_empty, tc)
213{
214    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_config test "
215                      "program");
216}
217ATF_TC_BODY(config_empty, tc)
218{
219    ATF_REQUIRE(atf_tc_has_config_var(tc, "test"));
220    ATF_REQUIRE(strlen(atf_tc_get_config_var(tc, "test")) == 0);
221}
222
223ATF_TC(config_value);
224ATF_TC_HEAD(config_value, tc)
225{
226    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_config test "
227                      "program");
228}
229ATF_TC_BODY(config_value, tc)
230{
231    ATF_REQUIRE(atf_tc_has_config_var(tc, "test"));
232    ATF_REQUIRE(strcmp(atf_tc_get_config_var(tc, "test"), "foo") == 0);
233}
234
235ATF_TC(config_multi_value);
236ATF_TC_HEAD(config_multi_value, tc)
237{
238    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_config test "
239                      "program");
240}
241ATF_TC_BODY(config_multi_value, tc)
242{
243    ATF_REQUIRE(atf_tc_has_config_var(tc, "test"));
244    ATF_REQUIRE(strcmp(atf_tc_get_config_var(tc, "test"), "foo bar") == 0);
245}
246
247/* ---------------------------------------------------------------------
248 * Helper tests for "t_expect".
249 * --------------------------------------------------------------------- */
250
251ATF_TC_WITHOUT_HEAD(expect_pass_and_pass);
252ATF_TC_BODY(expect_pass_and_pass, tc)
253{
254    atf_tc_expect_pass();
255
256}
257
258ATF_TC_WITHOUT_HEAD(expect_pass_but_fail_requirement);
259ATF_TC_BODY(expect_pass_but_fail_requirement, tc)
260{
261    atf_tc_expect_pass();
262    atf_tc_fail("Some reason");
263}
264
265ATF_TC_WITHOUT_HEAD(expect_pass_but_fail_check);
266ATF_TC_BODY(expect_pass_but_fail_check, tc)
267{
268    atf_tc_expect_pass();
269    atf_tc_fail_nonfatal("Some reason");
270}
271
272ATF_TC_WITHOUT_HEAD(expect_fail_and_fail_requirement);
273ATF_TC_BODY(expect_fail_and_fail_requirement, tc)
274{
275    atf_tc_expect_fail("Fail %s", "reason");
276    atf_tc_fail("The failure");
277    atf_tc_expect_pass();
278}
279
280ATF_TC_WITHOUT_HEAD(expect_fail_and_fail_check);
281ATF_TC_BODY(expect_fail_and_fail_check, tc)
282{
283    atf_tc_expect_fail("Fail first");
284    atf_tc_fail_nonfatal("abc");
285    atf_tc_expect_pass();
286
287    atf_tc_expect_fail("And fail again");
288    atf_tc_fail_nonfatal("def");
289    atf_tc_expect_pass();
290}
291
292ATF_TC_WITHOUT_HEAD(expect_fail_but_pass);
293ATF_TC_BODY(expect_fail_but_pass, tc)
294{
295    atf_tc_expect_fail("Fail first");
296    atf_tc_fail_nonfatal("abc");
297    atf_tc_expect_pass();
298
299    atf_tc_expect_fail("Will not fail");
300    atf_tc_expect_pass();
301
302    atf_tc_expect_fail("And fail again");
303    atf_tc_fail_nonfatal("def");
304    atf_tc_expect_pass();
305}
306
307ATF_TC_WITHOUT_HEAD(expect_exit_any_and_exit);
308ATF_TC_BODY(expect_exit_any_and_exit, tc)
309{
310    atf_tc_expect_exit(-1, "Call will exit");
311    exit(EXIT_SUCCESS);
312}
313
314ATF_TC_WITHOUT_HEAD(expect_exit_code_and_exit);
315ATF_TC_BODY(expect_exit_code_and_exit, tc)
316{
317    atf_tc_expect_exit(123, "Call will exit");
318    exit(123);
319}
320
321ATF_TC_WITHOUT_HEAD(expect_exit_but_pass);
322ATF_TC_BODY(expect_exit_but_pass, tc)
323{
324    atf_tc_expect_exit(-1, "Call won't exit");
325}
326
327ATF_TC_WITHOUT_HEAD(expect_signal_any_and_signal);
328ATF_TC_BODY(expect_signal_any_and_signal, tc)
329{
330    atf_tc_expect_signal(-1, "Call will signal");
331    kill(getpid(), SIGKILL);
332}
333
334ATF_TC_WITHOUT_HEAD(expect_signal_no_and_signal);
335ATF_TC_BODY(expect_signal_no_and_signal, tc)
336{
337    atf_tc_expect_signal(SIGHUP, "Call will signal");
338    kill(getpid(), SIGHUP);
339}
340
341ATF_TC_WITHOUT_HEAD(expect_signal_but_pass);
342ATF_TC_BODY(expect_signal_but_pass, tc)
343{
344    atf_tc_expect_signal(-1, "Call won't signal");
345}
346
347ATF_TC_WITHOUT_HEAD(expect_death_and_exit);
348ATF_TC_BODY(expect_death_and_exit, tc)
349{
350    atf_tc_expect_death("Exit case");
351    exit(123);
352}
353
354ATF_TC_WITHOUT_HEAD(expect_death_and_signal);
355ATF_TC_BODY(expect_death_and_signal, tc)
356{
357    atf_tc_expect_death("Signal case");
358    kill(getpid(), SIGKILL);
359}
360
361ATF_TC_WITHOUT_HEAD(expect_death_but_pass);
362ATF_TC_BODY(expect_death_but_pass, tc)
363{
364    atf_tc_expect_death("Call won't die");
365}
366
367ATF_TC(expect_timeout_and_hang);
368ATF_TC_HEAD(expect_timeout_and_hang, tc)
369{
370    atf_tc_set_md_var(tc, "timeout", "1");
371}
372ATF_TC_BODY(expect_timeout_and_hang, tc)
373{
374    atf_tc_expect_timeout("Will overrun");
375    sleep(5);
376}
377
378ATF_TC(expect_timeout_but_pass);
379ATF_TC_HEAD(expect_timeout_but_pass, tc)
380{
381    atf_tc_set_md_var(tc, "timeout", "1");
382}
383ATF_TC_BODY(expect_timeout_but_pass, tc)
384{
385    atf_tc_expect_timeout("Will just exit");
386}
387
388/* ---------------------------------------------------------------------
389 * Helper tests for "t_fork".
390 * --------------------------------------------------------------------- */
391
392ATF_TC(fork_stop);
393ATF_TC_HEAD(fork_stop, tc)
394{
395    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_fork test "
396                      "program");
397}
398ATF_TC_BODY(fork_stop, tc)
399{
400    FILE *f;
401    const char *dfstr, *pfstr;
402
403    dfstr = atf_tc_get_config_var(tc, "donefile");
404    pfstr = atf_tc_get_config_var(tc, "pidfile");
405
406    f = fopen(pfstr, "w");
407    if (f == NULL)
408        atf_tc_fail("Failed to create pidfile %s", pfstr);
409    fprintf(f, "%d", (int)getpid());
410    fclose(f);
411    printf("Wrote pid file\n");
412
413    printf("Waiting for done file\n");
414    while (access(dfstr, F_OK) != 0)
415        usleep(10000);
416    printf("Exiting\n");
417}
418
419/* ---------------------------------------------------------------------
420 * Helper tests for "t_meta_data".
421 * --------------------------------------------------------------------- */
422
423ATF_TC(metadata_no_descr);
424ATF_TC_HEAD(metadata_no_descr, tc)
425{
426}
427ATF_TC_BODY(metadata_no_descr, tc)
428{
429}
430
431ATF_TC_WITHOUT_HEAD(metadata_no_head);
432ATF_TC_BODY(metadata_no_head, tc)
433{
434}
435
436/* ---------------------------------------------------------------------
437 * Helper tests for "t_srcdir".
438 * --------------------------------------------------------------------- */
439
440ATF_TC(srcdir_exists);
441ATF_TC_HEAD(srcdir_exists, tc)
442{
443    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_srcdir test "
444                      "program");
445}
446ATF_TC_BODY(srcdir_exists, tc)
447{
448    atf_fs_path_t p;
449    bool b;
450
451    RE(atf_fs_path_init_fmt(&p, "%s/datafile",
452                            atf_tc_get_config_var(tc, "srcdir")));
453    RE(atf_fs_exists(&p, &b));
454    atf_fs_path_fini(&p);
455    if (!b)
456        atf_tc_fail("Cannot find datafile");
457}
458
459/* ---------------------------------------------------------------------
460 * Helper tests for "t_result".
461 * --------------------------------------------------------------------- */
462
463ATF_TC(result_pass);
464ATF_TC_HEAD(result_pass, tc) { }
465ATF_TC_BODY(result_pass, tc)
466{
467    printf("msg\n");
468}
469
470ATF_TC(result_fail);
471ATF_TC_HEAD(result_fail, tc) { }
472ATF_TC_BODY(result_fail, tc)
473{
474    printf("msg\n");
475    atf_tc_fail("Failure reason");
476}
477
478ATF_TC(result_skip);
479ATF_TC_HEAD(result_skip, tc) { }
480ATF_TC_BODY(result_skip, tc)
481{
482    printf("msg\n");
483    atf_tc_skip("Skipped reason");
484}
485
486ATF_TC(result_newlines_fail);
487ATF_TC_HEAD(result_newlines_fail, tc)
488{
489    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_result test "
490                      "program");
491}
492ATF_TC_BODY(result_newlines_fail, tc)
493{
494    atf_tc_fail("First line\nSecond line");
495}
496
497ATF_TC(result_newlines_skip);
498ATF_TC_HEAD(result_newlines_skip, tc)
499{
500    atf_tc_set_md_var(tc, "descr", "Helper test case for the t_result test "
501                      "program");
502}
503ATF_TC_BODY(result_newlines_skip, tc)
504{
505    atf_tc_skip("First line\nSecond line");
506}
507
508/* ---------------------------------------------------------------------
509 * Main.
510 * --------------------------------------------------------------------- */
511
512ATF_TP_ADD_TCS(tp)
513{
514    /* Add helper tests for t_cleanup. */
515    ATF_TP_ADD_TC(tp, cleanup_pass);
516    ATF_TP_ADD_TC(tp, cleanup_fail);
517    ATF_TP_ADD_TC(tp, cleanup_skip);
518    ATF_TP_ADD_TC(tp, cleanup_curdir);
519    ATF_TP_ADD_TC(tp, cleanup_sigterm);
520    ATF_TP_ADD_TC(tp, cleanup_fork);
521
522    /* Add helper tests for t_config. */
523    ATF_TP_ADD_TC(tp, config_unset);
524    ATF_TP_ADD_TC(tp, config_empty);
525    ATF_TP_ADD_TC(tp, config_value);
526    ATF_TP_ADD_TC(tp, config_multi_value);
527
528    /* Add helper tests for t_expect. */
529    ATF_TP_ADD_TC(tp, expect_pass_and_pass);
530    ATF_TP_ADD_TC(tp, expect_pass_but_fail_requirement);
531    ATF_TP_ADD_TC(tp, expect_pass_but_fail_check);
532    ATF_TP_ADD_TC(tp, expect_fail_and_fail_requirement);
533    ATF_TP_ADD_TC(tp, expect_fail_and_fail_check);
534    ATF_TP_ADD_TC(tp, expect_fail_but_pass);
535    ATF_TP_ADD_TC(tp, expect_exit_any_and_exit);
536    ATF_TP_ADD_TC(tp, expect_exit_code_and_exit);
537    ATF_TP_ADD_TC(tp, expect_exit_but_pass);
538    ATF_TP_ADD_TC(tp, expect_signal_any_and_signal);
539    ATF_TP_ADD_TC(tp, expect_signal_no_and_signal);
540    ATF_TP_ADD_TC(tp, expect_signal_but_pass);
541    ATF_TP_ADD_TC(tp, expect_death_and_exit);
542    ATF_TP_ADD_TC(tp, expect_death_and_signal);
543    ATF_TP_ADD_TC(tp, expect_death_but_pass);
544    ATF_TP_ADD_TC(tp, expect_timeout_and_hang);
545    ATF_TP_ADD_TC(tp, expect_timeout_but_pass);
546
547    /* Add helper tests for t_fork. */
548    ATF_TP_ADD_TC(tp, fork_stop);
549
550    /* Add helper tests for t_meta_data. */
551    ATF_TP_ADD_TC(tp, metadata_no_descr);
552    ATF_TP_ADD_TC(tp, metadata_no_head);
553
554    /* Add helper tests for t_srcdir. */
555    ATF_TP_ADD_TC(tp, srcdir_exists);
556
557    /* Add helper tests for t_result. */
558    ATF_TP_ADD_TC(tp, result_pass);
559    ATF_TP_ADD_TC(tp, result_fail);
560    ATF_TP_ADD_TC(tp, result_skip);
561    ATF_TP_ADD_TC(tp, result_newlines_fail);
562    ATF_TP_ADD_TC(tp, result_newlines_skip);
563
564    return atf_no_error();
565}
566