]> pd.if.org Git - zpackage/blob - t/ctap/ctap.c
add option to determine name from url
[zpackage] / t / ctap / ctap.c
1 #include <stdarg.h>
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include <errno.h>
5 #include <string.h>
6 #include <math.h>
7
8 #include "ctap.h"
9
10 /* global variable testnum? */
11 static int test = 0; /* the test number */
12 static int planned = 0;
13 static int intodo = 0;
14
15 void begin_todo(void) {
16         intodo = 1;
17 }
18
19 void end_todo(void) {
20         intodo = 0;
21 }
22
23 void plan(int tests) {
24         test = 0;
25         planned = tests;
26         printf("1..%d\n", tests);
27 }
28
29 static void print_lazy_plan(void) {
30         printf("1..%d\n", test);
31         fflush(stdout);
32 }
33
34 void plan_lazy(void) {
35         test = 0;
36         planned = 0;
37         atexit(print_lazy_plan);
38 }
39
40 void skip_all(const char *why, ...) {
41         printf("1..0");
42         if (why) {
43                 va_list args;
44                 printf(" # SKIP ");
45                 va_start(args, why);
46                 vfprintf(stdout, why, args);
47                 va_end(args);
48         }
49         printf("\n");
50 }
51
52 static void vfmtline(int pass, const char *directive, const char *fmt, va_list args) {
53         printf("%sok %d", pass ? "" : "not ", ++test);
54         if (fmt && !directive) {
55                 printf(" -");
56         }
57         if (directive) {
58                 printf(" # %s", directive);
59         }
60         if (fmt) {
61                 printf(" ");
62                 vfprintf(stdout, fmt, args);
63         }
64         printf("\n");
65 }
66
67 #if 0
68 static void fmtline(int pass, const char *info, const char *fmt, ...) {
69         va_list args;
70
71         va_start(args,fmt);
72         vfmtline(pass, info, fmt, args);
73         va_end(args);
74 }
75 #endif
76
77 void okv(int pass, const char *fmt, va_list args) {
78         vfmtline(pass, intodo ? "TODO" : 0, fmt, args);
79 }
80
81 void ok(int pass, char *fmt, ...) {
82         va_list args;
83
84         va_start(args, fmt);
85         okv(pass, fmt, args);
86         va_end(args);
87 }
88
89 void ok_block(unsigned long count, int pass, const char *fmt, ...) {
90         va_list args;
91         va_list copy;
92
93         if (count == 0) {
94                 return;
95         }
96
97         va_start(args, fmt);
98         while (count--) {
99                 va_copy(copy, args);
100                 okv(pass, fmt, copy);
101                 va_end(copy);
102         }
103         va_end(args);
104 }
105
106 void skip(const char *why, ...) {
107         va_list args;
108
109         va_start(args, why);
110         vfmtline(1, "SKIP", why, args);
111         va_end(args);
112 }
113
114 void skip_block(unsigned long count, const char *why, ...) {
115         va_list args;
116         va_list copy;
117         va_start(args, why);
118
119         while (count--) {
120                 va_copy(copy, args);
121                 vfmtline(1, "SKIP", why, args);
122                 va_end(copy);
123         }
124
125         va_end(args);
126 }
127
128 void bail(const char *fmt, ...) {
129         va_list args;
130         printf("Bail out!");
131         if (fmt) {
132                 va_start(args, fmt);
133                 vfprintf(stdout, fmt, args);
134                 va_end(args);
135         }
136         printf("\n");
137         fflush(stdout);
138         exit(1);
139 }
140
141 void sysbail(const char *fmt, ...) {
142         va_list args;
143         printf("Bail out!");
144         if (fmt) {
145                 va_start(args, fmt);
146                 vfprintf(stdout, fmt, args);
147                 va_end(args);
148         }
149         printf(": %s\n", strerror(errno));
150         fflush(stdout);
151         exit(1);
152 }
153
154 void sysdiag(const char *fmt, ...) {
155         va_list args;
156         if (!fmt) { return; }
157         printf("# ");
158         va_start(args, fmt);
159         vfprintf(stdout, fmt, args);
160         va_end(args);
161         printf(": %s\n", strerror(errno));
162 }
163
164 void diag(const char *fmt, ...) {
165         va_list args;
166         if (!fmt) { return; }
167         printf("# ");
168         va_start(args, fmt);
169         vfprintf(stdout, fmt, args);
170         va_end(args);
171         printf("\n");
172 }
173
174 void is_hex(unsigned long have, unsigned long want, const char *fmt, ...) {
175         va_list args;
176         int pass;
177
178         pass = have == want;
179         if (fmt) {
180                 va_start(args, fmt);
181                 okv(pass, fmt, args);
182                 va_end(args);
183         } else {
184                 ok(pass, NULL);
185         }
186         if (!pass) {
187                 diag("wanted: %ld", want);
188                 diag("got   : %ld", have);
189         }
190 }
191
192 void is_int(long have, long want, const char *fmt, ...) {
193         va_list args;
194         int pass;
195
196         pass = have == want;
197         if (fmt) {
198                 va_start(args, fmt);
199                 okv(pass, fmt, args);
200                 va_end(args);
201         } else {
202                 ok(pass, NULL);
203         }
204         if (!pass) {
205                 diag("wanted: %ld", want);
206                 diag("got   : %ld", have);
207         }
208 }
209
210 void is_double(double have, double want, double eps, const char *fmt, ...) {
211         int pass;
212         va_list args;
213
214         pass = fabs(want - have) <= eps;
215         if (fmt) {
216                 va_start(args, fmt);
217                 okv(pass, fmt, args);
218                 va_end(args);
219         } else {
220                 ok(pass, NULL);
221         }
222         if (!pass) {
223                 diag("wanted: %f", want);
224                 diag("got   : %f", have);
225         }
226 }
227
228 void is_compare(void *have, void *want,
229                 int (*cmp)(void *,void *),
230                 const char *fmt, ...
231                 ) {
232         int pass;
233         va_list args;
234
235         pass = !cmp(have, want);
236         if (fmt) {
237                 va_start(args, fmt);
238                 okv(pass, fmt, args);
239                 va_end(args);
240         } else {
241                 ok(pass, NULL);
242         }
243         /* no way to print them with out more functions
244         if (!pass) {
245                 diag("wanted: %s", want);
246                 diag("got   : %s", have);
247         }
248         */
249 }
250
251 int is_string(const char *have, const char *want, const char *fmt, ...) {
252         int pass;
253         va_list args;
254
255         pass = !strcmp(have,want);
256         if (fmt) {
257                 va_start(args, fmt);
258                 okv(pass, fmt, args);
259                 va_end(args);
260         } else {
261                 ok(pass, NULL);
262         }
263         if (!pass) {
264                 diag("wanted: %s", want);
265                 diag("got   : %s", have);
266         }
267         return pass;
268 }