[mLib] / test / t / tvec-test.c

/* -*-c-*-
 *
 * Test the test-vector framework
 *
 * (c) 2023 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the mLib utilities library.
 *
 * mLib is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * mLib is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with mLib.  If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "tvec.h"

/*----- Register definitions ----------------------------------------------*/

enum {
  /* Standard outputs. */
  RRC,					/* return code from deserialize */

  /* Output registers, one for each register type. */
  RI, RU, RIE, RUE, RPE, RF, RSTR, RBY, RBUF,

  /* Additional diagnostic outputs. */
  RSER,					/* serialized data */

  NROUT,

  /* Some additional inputs. */
  RSAB = NROUT,				/* which register to sabotage */

  NREG,

  /* Single register for copy tests. */
  RV = 0
};

static const struct tvec_iassoc ienum_assocs[] = {
  { "less",	       -1 },
  { "equal",		0 },
  { "greater",	       +1 },
  { 0 }
};

static const struct tvec_uassoc uenum_assocs[] = {
  { "apple",		0 },
  { "banana",		1 },
  { "clementine",	2 },
  { 0 }
};

static const struct tvec_passoc penum_assocs[] = {
  { "alice",		&uenum_assocs[0] },
  { "bob",		&uenum_assocs[1] },
  { "carol",		&uenum_assocs[2] },
  { 0 }
};

#if __STDC_VERSION__ >= 199901
#  define DSGINIT(x) x
#else
#  define DSGINIT(x)
#endif

static DSGINIT(const) struct tvec_enuminfo
  ienum_info = { "order", TVMISC_INT,
		 DSGINIT({ .i = { ienum_assocs COMMA &tvrange_i16 } }) },
  uenum_info = { "fruit", TVMISC_UINT,
		 DSGINIT({ .u = { uenum_assocs COMMA &tvrange_u16 } }) },
  penum_info = { "player", TVMISC_PTR,
		 DSGINIT({ .p = { penum_assocs } }) };

static const struct tvec_flag attr_flags[] = {
  { "black-fg",		0x07, 0x00 },
  { "blue-fg",		0x07, 0x01 },
  { "red-fg",		0x07, 0x02 },
  { "magenta-fg",	0x07, 0x03 },
  { "green-fg",		0x07, 0x04 },
  { "cyan-fg",		0x07, 0x05 },
  { "yellow-fg",	0x07, 0x06 },
  { "white-fg",		0x07, 0x07 },

  { "black-bg",		0x38, 0x00 },
  { "blue-bg",		0x38, 0x08 },
  { "red-bg",		0x38, 0x10 },
  { "magenta-bg",	0x38, 0x18 },
  { "green-bg",		0x38, 0x20 },
  { "cyan-bg",		0x38, 0x28 },
  { "yellow-bg",	0x38, 0x30 },
  { "white-bg",		0x38, 0x38 },

  { "normal",		0xc0, 0x00 },
  { "bright",		0x40, 0x40 },
  { "flash",		0x80, 0x80 },

  { 0 }
};

static const struct tvec_flaginfo attr_info =
  { "attr", attr_flags, &tvrange_u16 };

static const struct tvec_urange range_32 = { 0, 31 };

#define TYPEREGS(_)							\
  _(int,	RI,	int,			p, &tvrange_i16)	\
  _(uint,	RU,	uint,			p, &tvrange_u16)	\
  _(ienum,	RIE,	enum,			p, &ienum_info)		\
  _(uenum,	RUE,	enum,			p, &uenum_info)		\
  _(penum,	RPE,	enum,			p, &penum_info)		\
  _(flags,	RF,	flags,			p, &attr_info)		\
  _(string,	RSTR,	string,			p, &range_32)		\
  _(bytes,	RBY,	bytes,			p, &tvrange_byte)	\
  _(buffer,	RBUF,	buffer,			p, &tvrange_u16)

/*----- Serialization test ------------------------------------------------*/

struct test_context {
  struct tvec_state *tv;
};

static void capture_state_and_run(struct tvec_state *tv)
{
  struct test_context tctx;

  tctx.tv = tv; tv->test->fn(tv->in, tv->out, &tctx);
  if (!(tv->in[RRC].f&TVRF_LIVE)) {
    tv->in[RRC].v.i = 0;
    tv->in[RRC].f |= TVRF_LIVE; tv->out[RRC].f |= TVRF_LIVE;
  }
  tvec_check(tv, 0);
}

static void test_serialization
  (const struct tvec_reg *in, struct tvec_reg *out, void *ctx)
{
  struct test_context *tctx = ctx;
  struct tvec_state *tv = tctx->tv;
  const struct tvec_regdef *rd;
  union tvec_regval *rv;
  void *p; size_t sz;

  if (tvec_serialize(tv->in, tv->test->regs,
		     NROUT, sizeof(struct tvec_reg), &p, &sz))
    { out[RRC].v.i = -1; return; }
  out[RSER].f |= TVRF_LIVE;
  out[RSER].v.bytes.p = p; out[RSER].v.bytes.sz = sz;

  if (tvec_deserialize(tv->out, tv->test->regs,
			NROUT, sizeof(struct tvec_reg), p, sz))
    { out[RRC].v.i = -1; return; }

  if (in[RSAB].f&TVRF_LIVE) {
    for (rd = tv->test->regs; rd->name; rd++)
      if (STRCMP(in[RSAB].v.str.p, ==, rd->name)) {
	rv = &out[rd->i].v;
	if (rd->ty == &tvty_int ||
	    (rd->ty == &tvty_enum &&
	     ((struct tvec_enuminfo *)rd->arg.p)->mv == TVMISC_INT))
	  rv->i ^= 1;
	else if (rd->ty == &tvty_uint || rd->ty == &tvty_flags ||
		 (rd->ty == &tvty_enum &&
		  ((struct tvec_enuminfo *)rd->arg.p)->mv == TVMISC_INT))
	  rv->u ^= 1;
	else if (rd->ty == &tvty_string)
	  { if (rv->str.sz) rv->str.p[0] ^= 1; }
	else if (rd->ty == &tvty_bytes)
	  { if (rv->bytes.sz) rv->bytes.p[0] ^= 1; }
      }
  }

  out[RRC].v.i = 0;
}

DSGINIT(static) const struct tvec_regdef test_regs[] = {
#define DEFREG(name, i, ty, argslot, argval)				\
  { #name,	i,	&tvty_##ty,	TVRF_OPT,			\
					    DSGINIT({ .argslot = argval }) },
  TYPEREGS(DEFREG)
#undef DEFREG
  { "rc",	RRC,	&tvty_int,	TVRF_OPT,	{ &tvrange_int } },
  { "serialized", RSER,	&tvty_bytes,	TVRF_OPT },
  { "sabotage",	RSAB,	&tvty_string,	TVRF_OPT,	{ &tvrange_byte } },

  { 0 }
};

/*----- Single-type copy tests --------------------------------------------*/

static void test_copy_simple
  (const struct tvec_reg *in, struct tvec_reg *out, void *ctx)
  { out->v = in->v; }

static void test_copy_string
  (const struct tvec_reg *in, struct tvec_reg *out, void *ctx)
{
  tvec_allocstring(&out->v, in->v.str.sz);
  memcpy(out->v.str.p, in->v.str.p, in->v.str.sz);
}

static void test_copy_bytes
  (const struct tvec_reg *in, struct tvec_reg *out, void *ctx)
{
  tvec_allocstring(&out->v, in->v.str.sz);
  memcpy(out->v.str.p, in->v.str.p, in->v.str.sz);
}

#define test_copy_int test_copy_simple
#define test_copy_uint test_copy_simple
#define test_copy_ienum test_copy_simple
#define test_copy_uenum test_copy_simple
#define test_copy_penum test_copy_simple
#define test_copy_flags test_copy_simple
#define test_copy_buffer test_copy_bytes

#define SINGLEREG(name, i, ty, argslot, argval)				\
	DSGINIT(const) struct tvec_regdef name##_regs[] = {		\
	  { #name, RV, &tvty_##ty, 0, DSGINIT({ .argslot = argval }) },	\
	  { 0 }								\
	};
TYPEREGS(SINGLEREG)
#undef SINGLEREG

/*----- Front end ---------------------------------------------------------*/

static const struct tvec_test tests[] = {
  { "types",	test_regs,	0,	capture_state_and_run,
							test_serialization },

#define DEFCOPY(name, i, ty, argslot, argval)				\
  { #name,	name##_regs,	0,	tvec_runtest,	test_copy_##name },
  TYPEREGS(DEFCOPY)
#undef DEFCOPY

  { 0 }
};

static const struct tvec_info testinfo = {
  tests,
  NROUT, NREG, sizeof(struct tvec_reg)
};

int main(int argc, char *argv[])
{
#if __STDC_VERSION__ < 199901
#  define POKE(tag, ty, slot)						\
	slot##enum_info.u.slot.av = slot##enum_assocs;			\
  TVEC_MISCSLOTS(POKE)
#  undef POKE
#  define POKE(name, i, ty, argslot, argval)				\
	name##_regs->arg.argslot = argval;
  TYPEREGS(POKE)
#  undef POKE
#endif
  return (tvec_main(argc, argv, &testinfo, 0));
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
b64eb60f MW	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	enum {
	35	/* Standard outputs. */
	36	RRC, /* return code from deserialize */
	37
	38	/* Output registers, one for each register type. */
	39	RI, RU, RIE, RUE, RPE, RF, RSTR, RBY, RBUF,
	40
	41	/* Additional diagnostic outputs. */
	42	RSER, /* serialized data */
	43
	44	NROUT,
	45
	46	/* Some additional inputs. */
	47	RSAB = NROUT, /* which register to sabotage */
	48
	49	NREG,
	50
	51	/* Single register for copy tests. */
	52	RV = 0
	53	};
	54
	55	static const struct tvec_iassoc ienum_assocs[] = {
	56	{ "less", -1 },
	57	{ "equal", 0 },
	58	{ "greater", +1 },
	59	{ 0 }
	60	};
	61
	62	static const struct tvec_uassoc uenum_assocs[] = {
	63	{ "apple", 0 },
	64	{ "banana", 1 },
65	{ "clementine", 2 },
66	{ 0 }
67	};
68
69	static const struct tvec_passoc penum_assocs[] = {
70	{ "alice", &uenum_assocs[0] },
71	{ "bob", &uenum_assocs[1] },
72	{ "carol", &uenum_assocs[2] },
73	{ 0 }
74	};
75
76	#if __STDC_VERSION__ >= 199901
77	# define DSGINIT(x) x
78	#else
79	# define DSGINIT(x)
80	#endif
81
82	static DSGINIT(const) struct tvec_enuminfo
83	ienum_info = { "order", TVMISC_INT,
84	DSGINIT({ .i = { ienum_assocs COMMA &tvrange_i16 } }) },
85	uenum_info = { "fruit", TVMISC_UINT,
86	DSGINIT({ .u = { uenum_assocs COMMA &tvrange_u16 } }) },
87	penum_info = { "player", TVMISC_PTR,
88	DSGINIT({ .p = { penum_assocs } }) };
89
90	static const struct tvec_flag attr_flags[] = {
91	{ "black-fg", 0x07, 0x00 },
92	{ "blue-fg", 0x07, 0x01 },
93	{ "red-fg", 0x07, 0x02 },
94	{ "magenta-fg", 0x07, 0x03 },
95	{ "green-fg", 0x07, 0x04 },
96	{ "cyan-fg", 0x07, 0x05 },
97	{ "yellow-fg", 0x07, 0x06 },
98	{ "white-fg", 0x07, 0x07 },
99
100	{ "black-bg", 0x38, 0x00 },
101	{ "blue-bg", 0x38, 0x08 },
102	{ "red-bg", 0x38, 0x10 },
103	{ "magenta-bg", 0x38, 0x18 },
104	{ "green-bg", 0x38, 0x20 },
105	{ "cyan-bg", 0x38, 0x28 },
106	{ "yellow-bg", 0x38, 0x30 },
107	{ "white-bg", 0x38, 0x38 },
108
109	{ "normal", 0xc0, 0x00 },
110	{ "bright", 0x40, 0x40 },
111	{ "flash", 0x80, 0x80 },
112
113	{ 0 }
114	};
115
116	static const struct tvec_flaginfo attr_info =
117	{ "attr", attr_flags, &tvrange_u16 };
118
119	static const struct tvec_urange range_32 = { 0, 31 };
120
121	#define TYPEREGS(_) \
122	_(int, RI, int, p, &tvrange_i16) \
123	_(uint, RU, uint, p, &tvrange_u16) \
124	_(ienum, RIE, enum, p, &ienum_info) \
125	_(uenum, RUE, enum, p, &uenum_info) \
126	_(penum, RPE, enum, p, &penum_info) \
127	_(flags, RF, flags, p, &attr_info) \
128	_(string, RSTR, string, p, &range_32) \
129	_(bytes, RBY, bytes, p, &tvrange_byte) \
130	_(buffer, RBUF, buffer, p, &tvrange_u16)
131
132	/----- Serialization test ------------------------------------------------/
133
134	struct test_context {
135	struct tvec_state *tv;
136	};
137
138	static void capture_state_and_run(struct tvec_state *tv)
139	{
140	struct test_context tctx;
141
142	tctx.tv = tv; tv->test->fn(tv->in, tv->out, &tctx);
143	if (!(tv->in[RRC].f&TVRF_LIVE)) {
144	tv->in[RRC].v.i = 0;
145	tv->in[RRC].f \|= TVRF_LIVE; tv->out[RRC].f \|= TVRF_LIVE;
146	}
147	tvec_check(tv, 0);
148	}
149
150	static void test_serialization
151	(const struct tvec_reg in, struct tvec_reg out, void *ctx)
152	{
153	struct test_context *tctx = ctx;
154	struct tvec_state *tv = tctx->tv;
155	const struct tvec_regdef *rd;
156	union tvec_regval *rv;
157	void *p; size_t sz;
158
159	if (tvec_serialize(tv->in, tv->test->regs,
160	NROUT, sizeof(struct tvec_reg), &p, &sz))
161	{ out[RRC].v.i = -1; return; }
162	out[RSER].f \|= TVRF_LIVE;
163	out[RSER].v.bytes.p = p; out[RSER].v.bytes.sz = sz;
164
165	if (tvec_deserialize(tv->out, tv->test->regs,
166	NROUT, sizeof(struct tvec_reg), p, sz))
167	{ out[RRC].v.i = -1; return; }
168
169	if (in[RSAB].f&TVRF_LIVE) {
170	for (rd = tv->test->regs; rd->name; rd++)
171	if (STRCMP(in[RSAB].v.str.p, ==, rd->name)) {
172	rv = &out[rd->i].v;
173	if (rd->ty == &tvty_int \|\|
174	(rd->ty == &tvty_enum &&
175	((struct tvec_enuminfo *)rd->arg.p)->mv == TVMISC_INT))
176	rv->i ^= 1;
177	else if (rd->ty == &tvty_uint \|\| rd->ty == &tvty_flags \|\|
178	(rd->ty == &tvty_enum &&
179	((struct tvec_enuminfo *)rd->arg.p)->mv == TVMISC_INT))
180	rv->u ^= 1;
181	else if (rd->ty == &tvty_string)
182	{ if (rv->str.sz) rv->str.p[0] ^= 1; }
183	else if (rd->ty == &tvty_bytes)
184	{ if (rv->bytes.sz) rv->bytes.p[0] ^= 1; }
185	}
186	}
187
188	out[RRC].v.i = 0;
189	}
190
191	DSGINIT(static) const struct tvec_regdef test_regs[] = {
192	#define DEFREG(name, i, ty, argslot, argval) \
193	{ #name, i, &tvty_##ty, TVRF_OPT, \
194	DSGINIT({ .argslot = argval }) },
195	TYPEREGS(DEFREG)
196	#undef DEFREG
197	{ "rc", RRC, &tvty_int, TVRF_OPT, { &tvrange_int } },
198	{ "serialized", RSER, &tvty_bytes, TVRF_OPT },
199	{ "sabotage", RSAB, &tvty_string, TVRF_OPT, { &tvrange_byte } },
200
201	{ 0 }
202	};
203
204	/----- Single-type copy tests --------------------------------------------/
205
206	static void test_copy_simple
207	(const struct tvec_reg in, struct tvec_reg out, void *ctx)
208	{ out->v = in->v; }
209
210	static void test_copy_string
211	(const struct tvec_reg in, struct tvec_reg out, void *ctx)
212	{
213	tvec_allocstring(&out->v, in->v.str.sz);
214	memcpy(out->v.str.p, in->v.str.p, in->v.str.sz);
215	}
216
217	static void test_copy_bytes
218	(const struct tvec_reg in, struct tvec_reg out, void *ctx)
219	{
220	tvec_allocstring(&out->v, in->v.str.sz);
221	memcpy(out->v.str.p, in->v.str.p, in->v.str.sz);
222	}
223
224	#define test_copy_int test_copy_simple
225	#define test_copy_uint test_copy_simple
226	#define test_copy_ienum test_copy_simple
227	#define test_copy_uenum test_copy_simple
228	#define test_copy_penum test_copy_simple
229	#define test_copy_flags test_copy_simple
230	#define test_copy_buffer test_copy_bytes
231
232	#define SINGLEREG(name, i, ty, argslot, argval) \
233	DSGINIT(const) struct tvec_regdef name##_regs[] = { \
234	{ #name, RV, &tvty_##ty, 0, DSGINIT({ .argslot = argval }) }, \
235	{ 0 } \
236	};
237	TYPEREGS(SINGLEREG)
238	#undef SINGLEREG
239
240	/----- Front end ---------------------------------------------------------/
241
242	static const struct tvec_test tests[] = {
243	{ "types", test_regs, 0, capture_state_and_run,
244	test_serialization },
245
246	#define DEFCOPY(name, i, ty, argslot, argval) \
247	{ #name, name##_regs, 0, tvec_runtest, test_copy_##name },
248	TYPEREGS(DEFCOPY)
249	#undef DEFCOPY
250
251	{ 0 }
252	};
253
254	static const struct tvec_info testinfo = {
255	tests,
256	NROUT, NREG, sizeof(struct tvec_reg)
257	};
258
259	int main(int argc, char *argv[])
260	{
261	#if __STDC_VERSION__ < 199901
262	# define POKE(tag, ty, slot) \
263	slot##enum_info.u.slot.av = slot##enum_assocs; \
264	TVEC_MISCSLOTS(POKE)
265	# undef POKE
266	# define POKE(name, i, ty, argslot, argval) \
267	name##_regs->arg.argslot = argval;
268	TYPEREGS(POKE)
269	# undef POKE
270	#endif
271	return (tvec_main(argc, argv, &testinfo, 0));
272	}
273
274	/----- That's all, folks -------------------------------------------------/