chiark - git - mdw - mLib/blob - test/t/tvec-test.c

   1 /* -*-c-*-
   2  *
   3  * Test the test-vector framework
   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 "tvec.h"
  31
  32 /*----- Register definitions ----------------------------------------------*/
  33
  34 static const struct tvec_iassoc ienum_assocs[] = {
  35   { "less",            -1 },
  36   { "equal",            0 },
  37   { "greater",         +1 },
  38   { 0 }
  39 };
  40
  41 static const struct tvec_uassoc uenum_assocs[] = {
  42   { "apple",            0 },
  43   { "banana",           1 },
  44   { "clementine",       2 },
  45   { 0 }
  46 };
  47
  48 static const struct tvec_fassoc fenum_assocs[] = {
  49   { "e",                2.718281828459045 },
  50   { "pi",               3.141592653589793 },
  51   { "tau",              6.283185307179586 },
  52   { 0 }
  53 };
  54
  55 static const struct tvec_passoc penum_assocs[] = {
  56   { "alice",            &uenum_assocs[0] },
  57   { "bob",              &uenum_assocs[1] },
  58   { "carol",            &uenum_assocs[2] },
  59   { 0 }
  60 };
  61
  62 #if __STDC_VERSION__x >= 199901
  63 #  define DSGINIT(x) x
  64 #else
  65 #  define DSGINIT(x)
  66 #endif
  67
  68 static const struct tvec_floatinfo fenum_fltinfo =
  69   { TVFF_ABSDELTA, -10, +10, 1e-3 };
  70
  71 #define DEFENUM(tag, ty, slot)                                          \
  72   static const struct tvec_##slot##enuminfo slot##enum_info =           \
  73     { { slot##enum_NAME, TVMISC_##tag }, slot##enum_assocs slot##enum_ARGS };
  74 #define ienum_NAME "order"
  75 #define ienum_ARGS , &tvrange_i16
  76 #define uenum_NAME "fruit"
  77 #define uenum_ARGS , &tvrange_u16
  78 #define fenum_NAME "const"
  79 #define fenum_ARGS , &fenum_fltinfo
  80 #define penum_NAME "actor"
  81 #define penum_ARGS
  82 TVEC_MISCSLOTS(DEFENUM)
  83 #undef DEFENUM
  84
  85 static const struct tvec_flag attr_flags[] = {
  86   { "black-fg",         0x07, 0x00 },
  87   { "blue-fg",          0x07, 0x01 },
  88   { "red-fg",           0x07, 0x02 },
  89   { "magenta-fg",       0x07, 0x03 },
  90   { "green-fg",         0x07, 0x04 },
  91   { "cyan-fg",          0x07, 0x05 },
  92   { "yellow-fg",        0x07, 0x06 },
  93   { "white-fg",         0x07, 0x07 },
  94
  95   { "black-bg",         0x38, 0x00 },
  96   { "blue-bg",          0x38, 0x08 },
  97   { "red-bg",           0x38, 0x10 },
  98   { "magenta-bg",       0x38, 0x18 },
  99   { "green-bg",         0x38, 0x20 },
 100   { "cyan-bg",          0x38, 0x28 },
 101   { "yellow-bg",        0x38, 0x30 },
 102   { "white-bg",         0x38, 0x38 },
 103
 104   { "normal",           0xc0, 0x00 },
 105   { "bright",           0x40, 0x40 },
 106   { "flash",            0x80, 0x80 },
 107
 108   { 0 }
 109 };
 110
 111 static const struct tvec_flaginfo attr_info =
 112   { "attr", attr_flags, &tvrange_u16 };
 113
 114 static const struct tvec_floatinfo fltish_info =
 115   { TVFF_RELDELTA, -1.0, +1.0, 1e-6 };
 116
 117 static const struct tvec_urange range_32 = { 0, 31 };
 118
 119 #define TYPEREGS(_)                                                     \
 120   _(int,        RI,     int,                    p, &tvrange_i16)        \
 121   _(uint,       RU,     uint,                   p, &tvrange_u16)        \
 122   _(float,      RFP,    float,                  p, 0)                   \
 123   _(fltish,     RFISH,  float,                  p, &fltish_info)        \
 124   _(char,       RCH,    char,                   p, 0)                   \
 125   _(ienum,      RIE,    enum,                   p, &ienum_info)         \
 126   _(uenum,      RUE,    enum,                   p, &uenum_info)         \
 127   _(fenum,      RFE,    enum,                   p, &fenum_info)         \
 128   _(penum,      RPE,    enum,                   p, &penum_info)         \
 129   _(flags,      RF,     flags,                  p, &attr_info)          \
 130   _(string,     RSTR,   string,                 p, &range_32)           \
 131   _(bytes,      RBY,    bytes,                  p, &tvrange_byte)       \
 132   _(buffer,     RBUF,   buffer,                 p, &tvrange_u16)
 133
 134 enum {
 135   /* Output registers, one for each register type. */
 136 #define DEFREG(name, i, ty, argslot, argval) i,
 137   TYPEREGS(DEFREG)
 138 #undef DEFREG
 139   NSER,
 140
 141   /* Standard outputs. */
 142   RRC = NSER,                           /* return code from deserialize */
 143
 144   /* Additional diagnostic outputs. */
 145   RSER,                                 /* serialized data */
 146
 147   NROUT,
 148
 149   /* Some additional inputs. */
 150   RSAB = NROUT,                         /* which register to sabotage */
 151
 152   NREG,
 153
 154   /* Single register for copy tests. */
 155   RV = 0
 156 };
 157
 158 /*----- Serialization test ------------------------------------------------*/
 159
 160 struct test_context {
 161   struct tvec_state *tv;
 162 };
 163
 164 static int capture_setup(struct tvec_state *tv,
 165                          const struct tvec_env *env, void *pctx, void *ctx)
 166   { struct test_context *tctx = ctx; tctx->tv = tv; return (0); }
 167
 168 static void capture_run(struct tvec_state *tv, tvec_testfn *fn, void *ctx)
 169 {
 170   if (!(tv->in[RRC].f&TVRF_LIVE)) {
 171     tv->in[RRC].f |= TVRF_LIVE; tv->in[RRC].v.i = 0;
 172     tv->out[RRC].f |= TVRF_LIVE;
 173   }
 174   fn(tv->in, tv->out, ctx); tvec_check(tv, 0);
 175 }
 176 static const struct tvec_env capture_testenv =
 177   { sizeof(struct test_context), capture_setup, 0, 0, capture_run, 0, 0 };
 178
 179 static void test_serialization
 180   (const struct tvec_reg *in, struct tvec_reg *out, void *ctx)
 181 {
 182   struct test_context *tctx = ctx;
 183   struct tvec_state *tv = tctx->tv;
 184   const struct tvec_regdef *rd;
 185   union tvec_regval *rv;
 186   dbuf b = DBUF_INIT;
 187
 188   if (tvec_serialize(tv->in, DBUF_BUF(&b), tv->test->regs,
 189                      NSER, sizeof(struct tvec_reg)))
 190     { out[NSER].v.i = -1; goto end; }
 191   tvec_allocbytes(&out[RSER].v, DBLEN(&b));
 192   memcpy(out[RSER].v.bytes.p, DBBASE(&b), DBLEN(&b));
 193   out[RSER].f |= TVRF_LIVE;
 194   buf_flip(DBUF_BUF(&b));
 195
 196   if (tvec_deserialize(tv->out, DBUF_BUF(&b), tv->test->regs,
 197                        NSER, sizeof(struct tvec_reg)))
 198     { out[RRC].v.i = -2; goto end; }
 199   if (BLEFT(&b._b))
 200     { out[RRC].v.i = -3; goto end; }
 201
 202   if (in[RSAB].f&TVRF_LIVE) {
 203     for (rd = tv->test->regs; rd->name; rd++)
 204       if (STRCMP(in[RSAB].v.str.p, ==, rd->name)) {
 205         rv = &out[rd->i].v;
 206         if (rd->ty == &tvty_int ||
 207             (rd->ty == &tvty_enum &&
 208              ((const struct tvec_enuminfo *)rd->arg.p)->mv == TVMISC_INT))
 209           rv->i ^= 1;
 210         else if (rd->ty == &tvty_uint || rd->ty == &tvty_flags ||
 211                  (rd->ty == &tvty_enum &&
 212                   ((const struct tvec_enuminfo *)rd->arg.p)->mv ==
 213                     TVMISC_INT))
 214           rv->u ^= 1;
 215         else if (rd->ty == &tvty_enum &&
 216                  ((const struct tvec_enuminfo *)rd->arg.p)->mv == TVMISC_PTR)
 217           rv->p = rv->p
 218             ? 0
 219             : (/*unconst*/ void *)
 220                 ((const struct tvec_penuminfo *)rd->arg.p)->av[0].p;
 221         else if (rd->ty == &tvty_string)
 222           { if (rv->str.sz) rv->str.p[0] ^= 1; }
 223         else if (rd->ty == &tvty_bytes)
 224           { if (rv->bytes.sz) rv->bytes.p[0] ^= 1; }
 225       }
 226   }
 227
 228   out[RRC].v.i = 0;
 229 end:
 230   dbuf_destroy(&b);
 231 }
 232
 233 static DSGINIT(const) struct tvec_regdef test_regs[] = {
 234 #define DEFREG(name, i, ty, argslot, argval)                            \
 235   { #name,      i,      &tvty_##ty,     TVRF_OPT,                       \
 236                                             DSGINIT({ .argslot = argval }) },
 237   TYPEREGS(DEFREG)
 238 #undef DEFREG
 239   { "rc",       RRC,    &tvty_int,      TVRF_OPT,       { &tvrange_int } },
 240   { "serialized", RSER, &tvty_bytes,    TVRF_OPT },
 241   { "sabotage", RSAB,   &tvty_string,   TVRF_OPT,       { &tvrange_byte } },
 242
 243   { 0 }
 244 };
 245
 246 /*----- Single-type copy tests --------------------------------------------*/
 247
 248 static void test_copy_simple
 249   (const struct tvec_reg *in, struct tvec_reg *out, void *ctx)
 250   { out->v = in->v; }
 251
 252 static void test_copy_string
 253   (const struct tvec_reg *in, struct tvec_reg *out, void *ctx)
 254 {
 255   tvec_allocstring(&out->v, in->v.str.sz);
 256   memcpy(out->v.str.p, in->v.str.p, in->v.str.sz);
 257 }
 258
 259 static void test_copy_bytes
 260   (const struct tvec_reg *in, struct tvec_reg *out, void *ctx)
 261 {
 262   tvec_allocstring(&out->v, in->v.str.sz);
 263   memcpy(out->v.str.p, in->v.str.p, in->v.str.sz);
 264 }
 265
 266 #define test_copy_int test_copy_simple
 267 #define test_copy_uint test_copy_simple
 268 #define test_copy_ienum test_copy_simple
 269 #define test_copy_uenum test_copy_simple
 270 #define test_copy_fenum test_copy_simple
 271 #define test_copy_penum test_copy_simple
 272 #define test_copy_char test_copy_simple
 273 #define test_copy_flags test_copy_simple
 274 #define test_copy_float test_copy_simple
 275 #define test_copy_fltish test_copy_simple
 276 #define test_copy_buffer test_copy_bytes
 277
 278 #define SINGLEREG(name, i, ty, argslot, argval)                         \
 279         DSGINIT(const) struct tvec_regdef name##_regs[] = {             \
 280           { #name, RV, &tvty_##ty, 0, DSGINIT({ .argslot = argval }) }, \
 281           { 0 }                                                         \
 282         };
 283 TYPEREGS(SINGLEREG)
 284 #undef SINGLEREG
 285
 286 struct singlectx {
 287   unsigned f;
 288 #define SF_SHOW 1u
 289 };
 290
 291 static int single_setup(struct tvec_state *tv, const struct tvec_env *env,
 292                         void *pctx, void *ctx)
 293   { struct singlectx *s = ctx; s->f = 0; return (0); }
 294
 295 static int single_set(struct tvec_state *tv, const char *name,
 296                       const struct tvec_env *env, void *ctx)
 297 {
 298   struct singlectx *s = ctx;
 299   union tvec_regval rv;
 300   static const struct tvec_regdef rd =
 301     { "@show", -1, &tvty_enum, 0, { &tvenum_bool } };
 302
 303   if (STRCMP(name, ==, "@show")) {
 304     if (tvty_enum.parse(&rv, &rd, tv)) return (-1);
 305     if (s) {
 306       if (rv.i) s->f |= SF_SHOW;
 307       else s->f &= ~SF_SHOW;
 308     }
 309     return (1);
 310   } else
 311     return (0);
 312 }
 313
 314 static void single_run(struct tvec_state *tv, tvec_testfn *fn, void *ctx)
 315 {
 316   struct singlectx *s = ctx;
 317   unsigned f = s->f;
 318
 319   fn(tv->in, tv->out, 0);
 320   if (tvec_checkregs(tv)) { tvec_fail(tv, 0); f |= SF_SHOW; }
 321   if (f&SF_SHOW) tvec_mismatch(tv, TVMF_IN | TVMF_OUT);
 322 }
 323
 324 static void single_after(struct tvec_state *tv, void *ctx)
 325   { struct singlectx *s = ctx; s->f = 0; }
 326
 327 static const struct tvec_env single_testenv =
 328   { sizeof(struct singlectx),
 329     single_setup,
 330     single_set,
 331     0,
 332     single_run,
 333     single_after,
 334     0 };
 335
 336 /*----- Front end ---------------------------------------------------------*/
 337
 338 static const struct tvec_test tests[] = {
 339   { "types",    test_regs,      &capture_testenv,       test_serialization },
 340
 341 #define DEFCOPY(name, i, ty, argslot, argval)                           \
 342   { #name,      name##_regs,    &single_testenv,        test_copy_##name },
 343   TYPEREGS(DEFCOPY)
 344 #undef DEFCOPY
 345
 346   { 0 }
 347 };
 348
 349 static const struct tvec_info testinfo = {
 350   tests,
 351   NROUT, NREG, sizeof(struct tvec_reg)
 352 };
 353
 354 int main(int argc, char *argv[])
 355 {
 356 #if __STDC_VERSION__x < 199901
 357 #  define POKE(name, i, ty, argslot, argval)                            \
 358         test_regs[i].arg.argslot = argval;                              \
 359         name##_regs->arg.argslot = argval;
 360   TYPEREGS(POKE)
 361 #  undef POKE
 362 #endif
 363   return (tvec_main(argc, argv, &testinfo, 0));
 364 }
 365
 366 /*----- That's all, folks -------------------------------------------------*/