discover/grub2: Clean lexer.[ch]
[petitboot] / test / lib / test-process-both.c
1
2 #include <stdlib.h>
3 #include <string.h>
4 #include <assert.h>
5 #include <fcntl.h>
6 #include <sys/stat.h>
7
8 #include <process/process.h>
9 #include <waiter/waiter.h>
10 #include <talloc/talloc.h>
11
12 static const char *async_fifo = "/tmp/test-process-both.fifo";
13
14 static int do_sync_child(void)
15 {
16         return 42;
17 }
18
19 static int do_async_child(void)
20 {
21         char c;
22         int fd;
23
24         fd = open(async_fifo, O_RDONLY);
25         assert(fd >= 0);
26
27         read(fd, &c, 1);
28
29         assert(c == 1);
30
31         return 43;
32 }
33
34 struct test {
35         int             async_fd;
36         struct process  *sync_process;
37         struct process  *async_process;
38
39         bool            async_exited;
40         int             async_exit_status;
41
42 };
43
44 static void async_exit_cb(struct process *process)
45 {
46         struct test *test = process->data;
47         test->async_exited = true;
48         test->async_exit_status = process->exit_status;
49 }
50
51 int main(int argc, char **argv)
52 {
53         const char *sync_child_argv[3], *async_child_argv[3];
54         struct waitset *waitset;
55         struct test *test;
56         char c;
57         int rc;
58
59         if (argc == 2 && !strcmp(argv[1], "sync-child"))
60                 return do_sync_child();
61
62         if (argc == 2 && !strcmp(argv[1], "async-child"))
63                 return do_async_child();
64
65         test = talloc_zero(NULL, struct test);
66
67         unlink(async_fifo);
68         rc = mkfifo(async_fifo, 0600);
69         assert(rc == 0);
70
71         waitset = waitset_create(test);
72
73         process_init(test, waitset, false);
74
75         sync_child_argv[0] = argv[0];
76         sync_child_argv[1] = "sync-child";
77         sync_child_argv[2] = NULL;
78
79         test->sync_process = process_create(test);
80         test->sync_process->path = sync_child_argv[0];
81         test->sync_process->argv = sync_child_argv;
82
83         async_child_argv[0] = argv[0];
84         async_child_argv[1] = "async-child";
85         async_child_argv[2] = NULL;
86
87         test->async_process = process_create(test);
88         test->async_process->path = async_child_argv[0];
89         test->async_process->argv = async_child_argv;
90         test->async_process->exit_cb = async_exit_cb;
91         test->async_process->data = test;
92
93         process_run_async(test->async_process);
94
95         process_run_sync(test->sync_process);
96
97         assert(WIFEXITED(test->sync_process->exit_status));
98         assert(WEXITSTATUS(test->sync_process->exit_status) == 42);
99
100         /* now that the sync process has completed, let the async process
101          * exit */
102         test->async_fd = open(async_fifo, O_WRONLY);
103         assert(test->async_fd >= 0);
104         c = 1;
105         write(test->async_fd, &c, 1);
106
107         for (;;) {
108                 waiter_poll(waitset);
109
110                 if (test->async_exited)
111                         break;
112         }
113
114         assert(WIFEXITED(test->async_exit_status));
115         assert(WEXITSTATUS(test->async_exit_status) == 43);
116
117         talloc_free(test);
118
119         unlink(async_fifo);
120
121         return EXIT_SUCCESS;
122 }