~mdw / mLib / blob
? search:


3938397b07d6315d37dbce488d3620b4a35411bf
[mLib] / test / tvec-core.c
1 /* -*-c-*-
2 *
3 * Main test vector driver
4 *
5 * (c) 2023 Straylight/Edgeware
6 */
7
8 /*----- Licensing notice --------------------------------------------------*
9 *
10 * This file is part of the mLib utilities library.
11 *
12 * mLib is free software: you can redistribute it and/or modify it under
13 * the terms of the GNU Library General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or (at
15 * your option) any later version.
16 *
17 * mLib is distributed in the hope that it will be useful, but WITHOUT
18 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
20 * License for more details.
21 *
22 * You should have received a copy of the GNU Library General Public
23 * License along with mLib. If not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
25 * USA.
26 */
27
28 /*----- Header files ------------------------------------------------------*/
29
30 #include <assert.h>
31 #include <ctype.h>
32 #include <errno.h>
33 #include <string.h>
34
35 #include "alloc.h"
36 #include "bench.h"
37 #include "tvec.h"
38
39 /*----- Output ------------------------------------------------------------*/
40
41 int tvec_error(struct tvec_state *tv, const char *msg, ...)
42 {
43 va_list ap;
44
45 va_start(ap, msg); tvec_error_v(tv, msg, &ap); va_end(ap);
46 tv->f |= TVSF_ERROR; return (-1);
47 }
48 int tvec_error_v(struct tvec_state *tv, const char *msg, va_list *ap)
49 { tv->output->ops->error(tv->output, msg, ap); return (-1); }
50
51 void tvec_notice(struct tvec_state *tv, const char *msg, ...)
52 {
53 va_list ap;
54 va_start(ap, msg); tvec_notice_v(tv, msg, &ap); va_end(ap);
55 }
56 void tvec_notice_v(struct tvec_state *tv, const char *msg, va_list *ap)
57 { tv->output->ops->notice(tv->output, msg, ap); }
58
59 int tvec_syntax(struct tvec_state *tv, int ch, const char *expect, ...)
60 {
61 va_list ap;
62
63 va_start(ap, expect); tvec_syntax_v(tv, ch, expect, &ap); va_end(ap);
64 return (-1);
65 }
66 int tvec_syntax_v(struct tvec_state *tv, int ch,
67 const char *expect, va_list *ap)
68 {
69 dstr d = DSTR_INIT;
70 char found[8];
71
72 switch (ch) {
73 case EOF: strcpy(found, "<eof>"); break;
74 case '\n': strcpy(found, "<eol>"); ungetc(ch, tv->fp); break;
75 default:
76 if (isprint(ch)) sprintf(found, "`%c'", ch);
77 else sprintf(found, "<#x%02x>", ch);
78 break;
79 }
80 dstr_vputf(&d, expect, ap);
81 tvec_error(tv, "syntax error: expected %s but found %s", expect, found);
82 return (-1);
83 }
84
85 void tvec_skipgroup(struct tvec_state *tv, const char *excuse, ...)
86 {
87 va_list ap;
88 va_start(ap, excuse); tvec_skipgroup_v(tv, excuse, &ap); va_end(ap);
89 }
90 void tvec_skipgroup_v(struct tvec_state *tv, const char *excuse, va_list *ap)
91 {
92 tv->f |= TVSF_SKIP; tv->grps[TVOUT_SKIP]++;
93 tv->output->ops->skipgroup(tv->output, excuse, ap);
94 }
95
96 static void set_outcome(struct tvec_state *tv, unsigned out)
97 {
98 tv->f &= ~(TVSF_ACTIVE | TVSF_OUTMASK);
99 tv->f |= out << TVSF_OUTSHIFT;
100 }
101
102 void tvec_skip(struct tvec_state *tv, const char *excuse, ...)
103 {
104 va_list ap;
105 va_start(ap, excuse); tvec_skip_v(tv, excuse, &ap); va_end(ap);
106 }
107 void tvec_skip_v(struct tvec_state *tv, const char *excuse, va_list *ap)
108 {
109 assert(tv->f&TVSF_ACTIVE);
110 set_outcome(tv, TVOUT_SKIP);
111 tv->output->ops->skip(tv->output, excuse, ap);
112 }
113
114 void tvec_fail(struct tvec_state *tv, const char *detail, ...)
115 {
116 va_list ap;
117 va_start(ap, detail); tvec_fail_v(tv, detail, &ap); va_end(ap);
118 }
119 void tvec_fail_v(struct tvec_state *tv, const char *detail, va_list *ap)
120 {
121 assert((tv->f&TVSF_ACTIVE) ||
122 (tv->f&TVSF_OUTMASK) == (TVOUT_LOSE << TVSF_OUTSHIFT));
123 set_outcome(tv, TVOUT_LOSE); tv->output->ops->fail(tv->output, detail, ap);
124 }
125
126 void tvec_mismatch(struct tvec_state *tv)
127 { tv->output->ops->mismatch(tv->output); }
128
129 void tvec_write(struct tvec_state *tv, const char *p, ...)
130 {
131 va_list ap;
132 va_start(ap, p); tvec_write_v(tv, p, &ap); va_end(ap);
133 }
134 void tvec_write_v(struct tvec_state *tv, const char *p, va_list *ap)
135 {
136 dstr d = DSTR_INIT;
137
138 dstr_vputf(&d, p, ap); tv->output->ops->write(tv->output, d.buf, d.len);
139 DDESTROY(&d);
140 }
141
142 /*----- Serialization and deserialization ---------------------------------*/
143
144 int tvec_serialize(const struct tvec_reg *rv,
145 const struct tvec_regdef *regs,
146 unsigned nr, size_t regsz,
147 void **p_out, size_t *sz_out)
148 {
149 void *p = 0; buf b;
150 unsigned char *bitmap;
151 size_t i, nbits, bitsz, sz;
152 const struct tvec_regdef *rd;
153 const struct tvec_reg *r;
154 int rc;
155
156 for (rd = regs, nbits = 0, sz = 0; rd->name; rd++, nbits++) {
157 if (rd->i >= nr) continue;
158 r = TVEC_GREG(rv, rd->i, regsz); if (!(r->f&TVRF_LIVE)) continue;
159 sz += rd->ty->measure(&r->v, rd);
160 }
161 bitsz = (nbits + 7)/8; sz += bitsz;
162
163 p = xmalloc(sz); buf_init(&b, p, sz);
164 bitmap = buf_get(&b, bitsz); assert(bitmap); memset(bitmap, 0, bitsz);
165 for (rd = regs, i = 0; rd->name; rd++, i++) {
166 if (rd->i >= nr) continue;
167 r = TVEC_GREG(rv, rd->i, regsz); if (!(r->f&TVRF_LIVE)) continue;
168 bitmap[rd->i/8] |= 1 << rd->i%8;
169 if (rd->ty->tobuf(&b, &r->v, rd)) { rc = -1; goto end; }
170 }
171
172 if (BBAD(&b)) { rc = -1; goto end; }
173 *p_out = p; *sz_out = BLEN(&b); p = 0; rc = 0;
174 end:
175 xfree(p);
176 return (rc);
177 }
178
179 int tvec_deserialize(struct tvec_reg *rv,
180 const struct tvec_regdef *regs,
181 unsigned nr, size_t regsz,
182 const void *p, size_t sz)
183 {
184 buf b;
185 const unsigned char *bitmap;
186 size_t i, nbits, bitsz;
187 const struct tvec_regdef *rd;
188 struct tvec_reg *r;
189 int rc;
190
191 for (rd = regs, nbits = 0; rd->name; rd++, nbits++);
192 bitsz = (nbits + 7)/8; sz += bitsz;
193
194 buf_init(&b, (/*unconst*/ void *)p, sz);
195 bitmap = buf_get(&b, bitsz); if (!bitmap) { rc = -1; goto end; }
196 for (rd = regs, i = 0; rd->name; rd++, i++) {
197 if (rd->i >= nr) continue;
198 if (!(bitmap[rd->i/8]&(1 << rd->i%8))) continue;
199 r = TVEC_GREG(rv, rd->i, regsz);
200 if (rd->ty->frombuf(&b, &r->v, rd)) { rc = -1; goto end; }
201 r->f |= TVRF_LIVE;
202 }
203
204 if (BBAD(&b)) { rc = -1; goto end; }
205 rc = 0;
206 end:
207 return (rc);
208 }
209
210 /*----- Benchmarking ------------------------------------------------------*/
211
212 struct bench_state *tvec_benchstate;
213
214 struct benchrun {
215 unsigned long *n;
216 tvec_testfn *fn;
217 const struct tvec_reg *in; struct tvec_reg *out;
218 void *ctx;
219 };
220
221 static void benchloop_outer(unsigned long n, void *p)
222 { struct benchrun *r = p; while (n--) r->fn(r->in, r->out, r->ctx); }
223
224 static void benchloop_inner(unsigned long n, void *p)
225 { struct benchrun *r = p; *r->n = n; r->fn(r->in, r->out, r->ctx); }
226
227 int tvec_ensurebench(struct tvec_state *tv, struct bench_state **b_out)
228 {
229 const struct tvec_bench *tvb = tv->test->arg.p;
230 struct bench_state **bb;
231 struct bench_timer *bt;
232
233 if (tvb->b) bb = tvb->b;
234 else bb = &tvec_benchstate;
235
236 if (!*bb) {
237 bt = bench_createtimer();
238 if (!bt) { tvec_skip(tv, "failed to create timer"); return (-1); }
239 *bb = xmalloc(sizeof(**bb)); bench_init(*bb, bt);
240 } else if (!(*bb)->tm)
241 { tvec_skip(tv, "failed to create timer"); return (-1); }
242
243 *b_out = *bb;
244 return (0);
245 }
246
247 int tvec_bench(struct tvec_state *tv)
248 {
249 const struct tvec_bench *tvb = tv->test->arg.p;
250 struct bench_state *b;
251 struct bench_timing tm;
252 struct benchrun r;
253 bench_fn *loopfn;
254
255 if (tvec_ensurebench(tv, &b)) goto end_0;
256
257 r.in = tv->in; r.out = tv->out; r.fn = tv->test->fn;
258 if (tvb->ctxsz) r.ctx = xmalloc(tvb->ctxsz);
259 else r.ctx = 0;
260 if (tvb->setup && tvb->setup(tv->in, tv->out, &tvb->arg, r.ctx))
261 { tvec_skip(tv, "benchmark setup failed"); goto end_1; }
262
263 if (tvb->riter < 0)
264 { r.n = 0; loopfn = benchloop_outer; }
265 else
266 { r.n = &TVEC_REG(tv, in, tvb->riter)->v.u; loopfn = benchloop_inner; }
267
268 tv->output->ops->bbench(tv->output);
269 if (bench_measure(&tm, b, loopfn, &r))
270 { tv->output->ops->ebench(tv->output, 0); goto end_2; }
271 tv->output->ops->ebench(tv->output, &tm);
272
273 end_2:
274 if (tvb->teardown) tvb->teardown(r.ctx);
275 end_1:
276 if (r.ctx) xfree(r.ctx);
277 end_0:
278 return (0);
279 }
280
281 /*----- Main machinery ----------------------------------------------------*/
282
283 void tvec_skipspc(struct tvec_state *tv)
284 {
285 int ch;
286
287 for (;;) {
288 ch = getc(tv->fp);
289 if (ch == EOF) break;
290 else if (ch == '\n' || !isspace(ch)) { ungetc(ch, tv->fp); break; }
291 }
292 }
293
294 int tvec_flushtoeol(struct tvec_state *tv, unsigned f)
295 {
296 int ch, rc = 0;
297
298 for (;;) {
299 ch = getc(tv->fp);
300 switch (ch) {
301 case '\n': tv->lno++; return (rc);
302 case EOF: return (rc);
303 case ';': f |= TVFF_ALLOWANY; break;
304 default:
305 if (!(f&TVFF_ALLOWANY) && !isspace(ch)) {
306 tvec_syntax(tv, ch, "end-of-line");
307 rc = -1; f |= TVFF_ALLOWANY;
308 }
309 break;
310 }
311 }
312 }
313
314 int tvec_nexttoken(struct tvec_state *tv)
315 {
316 enum { TAIL, NEWLINE, INDENT, COMMENT };
317 int ch;
318 unsigned s = TAIL;
319
320 for (;;) {
321 ch = getc(tv->fp);
322 switch (ch) {
323 case EOF:
324 return (-1);
325
326 case ';':
327 s = COMMENT;
328 break;
329
330 case '\n':
331 if (s == NEWLINE || s == INDENT) { ungetc(ch, tv->fp); return (-1); }
332 else { tv->lno++; s = NEWLINE; }
333 break;
334
335 default:
336 if (isspace(ch))
337 { if (s == NEWLINE) s = INDENT; }
338 else if (s != COMMENT) {
339 ungetc(ch, tv->fp);
340 if (s == NEWLINE) return (-1);
341 else return (0);
342 }
343 break;
344 }
345 }
346 }
347
348 int tvec_readword(struct tvec_state *tv, dstr *d, const char *delims,
349 const char *expect, ...)
350 {
351 va_list ap;
352 int rc;
353
354 va_start(ap, expect);
355 rc = tvec_readword_v(tv, d, delims, expect, &ap);
356 va_end(ap);
357 return (rc);
358 }
359 int tvec_readword_v(struct tvec_state *tv, dstr *d, const char *delims,
360 const char *expect, va_list *ap)
361 {
362 int ch;
363
364 ch = getc(tv->fp);
365 if (ch == '\n' || ch == EOF || ch == ';' ||
366 (delims && strchr(delims, ch))) {
367 if (expect) return (tvec_syntax(tv, ch, expect, ap));
368 else { ungetc(ch, tv->fp); return (-1); }
369 }
370 if (d->len) DPUTC(d, ' ');
371 do {
372 DPUTC(d, ch);
373 ch = getc(tv->fp);
374 } while (ch != EOF && !isspace(ch) && (!delims || !strchr(delims, ch)));
375 DPUTZ(d); if (ch != EOF) ungetc(ch, tv->fp);
376 return (0);
377 }
378
379 static void init_registers(struct tvec_state *tv)
380 {
381 const struct tvec_regdef *rd;
382 struct tvec_reg *r;
383
384 for (rd = tv->test->regs; rd->name; rd++) {
385 assert(rd->i < tv->nreg); r = TVEC_REG(tv, in, rd->i);
386 rd->ty->init(&r->v, rd); r->f = 0;
387 if (rd->i < tv->nrout)
388 { r = TVEC_REG(tv, out, rd->i); rd->ty->init(&r->v, rd); r->f = 0; }
389 }
390 tv->expst = '.';
391 }
392
393 static void release_registers(struct tvec_state *tv)
394 {
395 const struct tvec_regdef *rd;
396 struct tvec_reg *r;
397
398 for (rd = tv->test->regs; rd->name; rd++) {
399 assert(rd->i < tv->nreg); r = TVEC_REG(tv, in, rd->i);
400 rd->ty->release(&r->v, rd); r->f = 0;
401 if (rd->i < tv->nrout)
402 { r = TVEC_REG(tv, out, rd->i); rd->ty->release(&r->v, rd); r->f = 0; }
403 }
404 }
405
406 void tvec_check(struct tvec_state *tv, const char *detail, ...)
407 {
408 va_list ap;
409 va_start(ap, detail); tvec_check_v(tv, detail, &ap); va_end(ap);
410 }
411 void tvec_check_v(struct tvec_state *tv, const char *detail, va_list *ap)
412 {
413 const struct tvec_regdef *rd;
414 const struct tvec_reg *rin, *rout;
415 unsigned f = 0;
416 #define f_mismatch 1u
417
418 if (tv->expst != tv->st) f |= f_mismatch;
419 for (rd = tv->test->regs; rd->name; rd++) {
420 if (rd->i >= tv->nrout) continue;
421 rin = TVEC_REG(tv, in, rd->i); rout = TVEC_REG(tv, out, rd->i);
422 if (!rin->f&TVRF_LIVE) continue;
423 if (!rd->ty->eq(&rin->v, &rout->v, rd)) f |= f_mismatch;
424 }
425 if (!(f&f_mismatch)) return;
426
427 tvec_fail_v(tv, detail, ap);
428 tvec_mismatch(tv);
429
430 #undef f_mismatch
431 }
432
433 int tvec_runtest(struct tvec_state *tv)
434 {
435 tv->test->fn(tv->in, tv->out, (/*unconst*/ void *)tv->test->arg.p);
436 tvec_check(tv, 0); return (0);
437 }
438
439 static void begin_test(struct tvec_state *tv)
440 {
441 tv->f |= TVSF_ACTIVE; tv->f &= ~TVSF_OUTMASK; tv->st = '.';
442 tv->output->ops->btest(tv->output);
443 }
444
445 void tvec_endtest(struct tvec_state *tv)
446 {
447 unsigned out;
448
449 if (tv->f&TVSF_ACTIVE) out = TVOUT_WIN;
450 else out = (tv->f&TVSF_OUTMASK) >> TVSF_OUTSHIFT;
451 assert(out < TVOUT_LIMIT); tv->curr[out]++;
452 tv->output->ops->etest(tv->output, out);
453 tv->f &= ~TVSF_OPEN;
454 }
455
456 static void check(struct tvec_state *tv)
457 {
458 const struct tvec_regdef *rd;
459
460 if (!(tv->f&TVSF_OPEN)) return;
461
462 for (rd = tv->test->regs; rd->name; rd++) {
463 if (TVEC_REG(tv, in, rd->i)->f&TVRF_LIVE)
464 { if (rd->i < tv->nrout) TVEC_REG(tv, out, rd->i)->f |= TVRF_LIVE; }
465 else if (!(rd->f&TVRF_OPT)) {
466 tvec_error(tv, "required register `%s' not set in test `%s'",
467 rd->name, tv->test->name);
468 goto end;
469 }
470 }
471
472 if (!(tv->f&TVSF_SKIP))
473 { begin_test(tv); tv->test->run(tv); tvec_endtest(tv); }
474
475 end:
476 tv->f &= ~TVSF_OPEN; release_registers(tv); init_registers(tv);
477 }
478
479 static void begin_test_group(struct tvec_state *tv)
480 {
481 unsigned i;
482
483 tv->output->ops->bgroup(tv->output);
484 tv->f &= ~TVSF_SKIP;
485 init_registers(tv);
486 for (i = 0; i < TVOUT_LIMIT; i++) tv->curr[i] = 0;
487 if (tv->test->preflight) tv->test->preflight(tv);
488 }
489
490 void tvec_reportgroup(struct tvec_state *tv)
491 {
492 unsigned i, out, nrun;
493
494 for (i = 0, nrun = 0; i < TVOUT_LIMIT; i++)
495 { nrun += tv->curr[i]; tv->all[i] += tv->curr[i]; }
496
497 if (tv->curr[TVOUT_SKIP] == nrun)
498 { out = TVOUT_SKIP; tvec_skipgroup(tv, nrun ? 0 : "no tests to run"); }
499 else {
500 if (tv->curr[TVOUT_LOSE]) out = TVOUT_LOSE;
501 else out = TVOUT_WIN;
502 tv->grps[out]++; tv->output->ops->egroup(tv->output, out);
503 }
504 }
505
506 static void end_test_group(struct tvec_state *tv)
507 {
508 if (!tv->test) return;
509 if (tv->f&TVSF_OPEN) check(tv);
510 if (!(tv->f&TVSF_SKIP)) tvec_reportgroup(tv);
511 release_registers(tv); tv->test = 0;
512 }
513
514 int tvec_read(struct tvec_state *tv, const char *infile, FILE *fp)
515 {
516 dstr d = DSTR_INIT;
517 const struct tvec_test *test;
518 const struct tvec_regdef *rd;
519 struct tvec_reg *r;
520 int ch;
521 int rc = 0;
522
523 tv->infile = infile; tv->lno = 1; tv->fp = fp;
524
525 for (;;) {
526 ch = getc(tv->fp);
527 switch (ch) {
528
529 case EOF:
530 goto end;
531
532 case '[':
533 end_test_group(tv);
534 tvec_skipspc(tv);
535 DRESET(&d); tvec_readword(tv, &d, "];", "group name");
536 tvec_skipspc(tv);
537 ch = getc(tv->fp); if (ch != ']') tvec_syntax(tv, ch, "`]'");
538 for (test = tv->tests; test->name; test++)
539 if (STRCMP(d.buf, ==, test->name)) goto found_test;
540 tvec_error(tv, "unknown test group `%s'", d.buf); goto flush_line;
541 found_test:
542 tvec_flushtoeol(tv, 0); tv->test = test; begin_test_group(tv);
543 break;
544
545 case '\n':
546 tv->lno++;
547 if (tv->f&TVSF_OPEN) check(tv);
548 break;
549
550 default:
551 if (isspace(ch)) {
552 tvec_skipspc(tv);
553 ch = getc(tv->fp);
554 if (ch == EOF) goto end;
555 else if (ch == ';') tvec_flushtoeol(tv, TVFF_ALLOWANY);
556 else if (tvec_flushtoeol(tv, 0)) rc = -1;
557 else check(tv);
558 } else if (ch == ';')
559 tvec_flushtoeol(tv, TVFF_ALLOWANY);
560 else {
561 ungetc(ch, tv->fp);
562 DRESET(&d);
563 if (tvec_readword(tv, &d, "=:;", "register name")) goto flush_line;
564 tvec_skipspc(tv); ch = getc(tv->fp);
565 if (ch != '=' && ch != ':')
566 { tvec_syntax(tv, ch, "`=' or `:'"); goto flush_line; }
567 tvec_skipspc(tv);
568 if (d.buf[0] == '@') {
569 if (STRCMP(d.buf, ==, "@status")) {
570 if (!(tv->f&TVSF_OPEN))
571 { tv->test_lno = tv->lno; tv->f |= TVSF_OPEN; }
572 ch = getc(tv->fp);
573 if (ch == EOF || ch == '\n' || ch == ';')
574 { tvec_syntax(tv, ch, "status character"); goto flush_line; }
575 else if (ch == '\\') {
576 ch = getc(tv->fp);
577 if (ch == EOF || ch == '\n') {
578 tvec_syntax(tv, ch, "escaped status character");
579 goto flush_line;
580 }
581 }
582 tv->expst = ch;
583 tvec_flushtoeol(tv, 0);
584 } else {
585 tvec_error(tv, "unknown special register `%s'", d.buf);
586 goto flush_line;
587 }
588 } else {
589 if (!tv->test)
590 { tvec_error(tv, "no current test"); goto flush_line; }
591 for (rd = tv->test->regs; rd->name; rd++)
592 if (STRCMP(rd->name, ==, d.buf)) goto found_reg;
593 tvec_error(tv, "unknown register `%s' for test `%s'",
594 d.buf, tv->test->name);
595 goto flush_line;
596 found_reg:
597 if (!(tv->f&TVSF_OPEN))
598 { tv->test_lno = tv->lno; tv->f |= TVSF_OPEN; }
599 tvec_skipspc(tv);
600 r = TVEC_REG(tv, in, rd->i);
601 if (r->f&TVRF_LIVE) {
602 tvec_error(tv, "register `%s' already set", rd->name);
603 goto flush_line;
604 }
605 if (rd->ty->parse(&r->v, rd, tv)) goto flush_line;
606 r->f |= TVRF_LIVE;
607 }
608 }
609 break;
610 }
611 continue;
612
613 flush_line:
614 tvec_flushtoeol(tv, TVFF_ALLOWANY); rc = -1;
615 }
616 if (ferror(tv->fp))
617 { tvec_error(tv, "error reading input: %s", strerror(errno)); rc = -1; }
618 end:
619 end_test_group(tv);
620 tv->infile = 0; tv->fp = 0;
621 dstr_destroy(&d);
622 return (rc);
623 }
624
625 /*----- Ad-hoc testing ----------------------------------------------------*/
626
627 static const struct tvec_regdef no_regs = { 0, 0, 0, 0, { 0 } };
628
629 static int fakerun(struct tvec_state *tv)
630 { assert(!"fake run function"); }
631 static void fakefn(const struct tvec_reg *in, struct tvec_reg *out, void *p)
632 { assert(!"fake test function"); }
633
634 void tvec_adhoc(struct tvec_state *tv, struct tvec_test *t)
635 {
636 t->name = "<unset>"; t->regs = &no_regs;
637 t->preflight = 0; t->run = fakerun; t->fn = fakefn; t->arg.p = 0;
638 tv->tests = t;
639 }
640
641 void tvec_begingroup(struct tvec_state *tv, const char *name,
642 const char *file, unsigned lno)
643 {
644 struct tvec_test *t = (/*unconst*/ struct tvec_test *)tv->tests;
645
646 t->name = name; tv->test = t;
647 tv->infile = file; tv->lno = tv->test_lno = lno;
648 begin_test_group(tv);
649 }
650
651 void tvec_endgroup(struct tvec_state *tv)
652 {
653 if (!(tv->f&TVSF_SKIP)) tvec_reportgroup(tv);
654 tv->test = 0;
655 }
656
657 void tvec_begintest(struct tvec_state *tv, const char *file, unsigned lno)
658 {
659 tv->infile = file; tv->lno = tv->test_lno = lno;
660 begin_test(tv); tv->f |= TVSF_OPEN;
661 }
662
663 struct adhoc_claim {
664 unsigned f;
665 #define ACF_FRESH 1u
666 const char *saved_file; unsigned saved_lno;
667 };
668
669 static void adhoc_claim_setup(struct tvec_state *tv,
670 struct adhoc_claim *ck,
671 const struct tvec_regdef *regs,
672 const char *file, unsigned lno)
673 {
674 struct tvec_test *t = (/*unconst*/ struct tvec_test *)tv->test;
675
676 ck->f = 0;
677
678 if (!(tv->f&TVSF_OPEN))
679 { ck->f |= ACF_FRESH; tvec_begintest(tv, file, lno); }
680
681 ck->saved_file = tv->infile; if (file) tv->infile = file;
682 ck->saved_lno = tv->test_lno; if (file) tv->test_lno = lno;
683 t->regs = regs ? regs : &no_regs;
684
685 tv->st = '.';
686 }
687
688 static void adhoc_claim_teardown(struct tvec_state *tv,
689 struct adhoc_claim *ck)
690 {
691 struct tvec_test *t = (/*unconst*/ struct tvec_test *)tv->test;
692
693 t->regs = &no_regs;
694 tv->infile = ck->saved_file; tv->test_lno = ck->saved_lno;
695
696 if (ck->f&ACF_FRESH) tvec_endtest(tv);
697 }
698
699 int tvec_claim(struct tvec_state *tv, int ok,
700 const char *file, unsigned lno, const char *expr, ...)
701 {
702 struct adhoc_claim ck;
703 va_list ap;
704
705 adhoc_claim_setup(tv, &ck, 0, file, lno);
706 if (!ok)
707 { va_start(ap, expr); tvec_fail_v(tv, expr, &ap); va_end(ap); }
708 adhoc_claim_teardown(tv, &ck);
709 return (ok);
710 }
711
712 int tvec_claimeq(struct tvec_state *tv,
713 const struct tvec_regty *ty, const union tvec_misc *arg,
714 const char *file, unsigned lno, const char *expr)
715 {
716 struct tvec_regdef regs[2];
717 struct adhoc_claim ck;
718 int ok;
719
720 tv->in[0].f = tv->out[0].f = TVRF_LIVE;
721
722 regs[0].name = "value"; regs[0].i = 0;
723 regs[0].ty = ty; regs[0].f = 0;
724 if (arg) regs[0].arg = *arg;
725 else regs[0].arg.p = 0;
726
727 regs[1].name = 0;
728
729 adhoc_claim_setup(tv, &ck, regs, file, lno);
730 ok = ty->eq(&tv->in[0].v, &tv->out[0].v, &regs[0]);
731 if (!ok) { tvec_fail(tv, "%s", expr ); tvec_mismatch(tv); }
732 adhoc_claim_teardown(tv, &ck);
733 return (ok);
734 }
735
736 /*----- Session lifecycle -------------------------------------------------*/
737
738 void tvec_begin(struct tvec_state *tv_out,
739 const struct tvec_info *info,
740 struct tvec_output *o)
741 {
742 unsigned i;
743
744 tv_out->f = 0;
745
746 assert(info->nrout <= info->nreg);
747 tv_out->nrout = info->nrout; tv_out->nreg = info->nreg;
748 tv_out->regsz = info->regsz;
749 tv_out->in = xmalloc(tv_out->nreg*tv_out->regsz);
750 tv_out->out = xmalloc(tv_out->nrout*tv_out->regsz);
751 for (i = 0; i < tv_out->nreg; i++) {
752 TVEC_REG(tv_out, in, i)->f = 0;
753 if (i < tv_out->nrout) TVEC_REG(tv_out, out, i)->f = 0;
754 }
755
756 for (i = 0; i < TVOUT_LIMIT; i++)
757 tv_out->curr[i] = tv_out->all[i] = tv_out->grps[i] = 0;
758
759 tv_out->tests = info->tests; tv_out->test = 0;
760 tv_out->infile = 0; tv_out->lno = 0; tv_out->fp = 0;
761 o->tv = tv_out; tv_out->output = o;
762
763 tv_out->output->ops->bsession(tv_out->output);
764 }
765
766 int tvec_end(struct tvec_state *tv)
767 {
768 int rc = tv->output->ops->esession(tv->output);
769
770 tv->output->ops->destroy(tv->output);
771 xfree(tv->in); xfree(tv->out);
772 return (rc);
773 }
774
775 /*----- That's all, folks -------------------------------------------------*/
mLib utilities library