[libside.git] / src / test.c

// SPDX-License-Identifier: MIT
/*
 * Copyright 2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 */

#include <stdint.h>
#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>

#include <side/trace.h>
#include "tracer.h"

/* User code example */

static side_define_event(my_provider_event, "myprovider", "myevent", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field(SIDE_TYPE_U32, "abc"),
		side_field(SIDE_TYPE_S64, "def"),
		side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	)
);

static
void test_fields(void)
{
	uint32_t uw = 42;
	int64_t sdw = -500;

	my_provider_event.enabled = 1;
	side_event(&my_provider_event, side_arg_list(side_arg_u32(uw), side_arg_s64(sdw),
		side_arg_dynamic(side_arg_dynamic_string("zzz"))));
}

static side_define_event(my_provider_event2, "myprovider", "myevent2", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field_struct("structfield",
			side_field_list(
				side_field(SIDE_TYPE_U32, "x"),
				side_field(SIDE_TYPE_S64, "y"),
			)
		),
		side_field(SIDE_TYPE_U8, "z"),
	)
);

static
void test_struct(void)
{
	my_provider_event2.enabled = 1;
	side_event_cond(&my_provider_event2) {
		side_arg_define_vec(mystruct, side_arg_list(side_arg_u32(21), side_arg_s64(22)));
		side_event_call(&my_provider_event2, side_arg_list(side_arg_struct(&mystruct), side_arg_u8(55)));
	}
}

static side_define_event(my_provider_event_array, "myprovider", "myarray", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field_array("arr", side_elem_type(SIDE_TYPE_U32), 3),
		side_field(SIDE_TYPE_S64, "v"),
	)
);

static
void test_array(void)
{
	my_provider_event_array.enabled = 1;
	side_event_cond(&my_provider_event_array) {
		side_arg_define_vec(myarray, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
		side_event_call(&my_provider_event_array, side_arg_list(side_arg_array(&myarray), side_arg_s64(42)));
	}
}

static side_define_event(my_provider_event_vla, "myprovider", "myvla", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field_vla("vla", side_elem_type(SIDE_TYPE_U32)),
		side_field(SIDE_TYPE_S64, "v"),
	)
);

static
void test_vla(void)
{
	my_provider_event_vla.enabled = 1;
	side_event_cond(&my_provider_event_vla) {
		side_arg_define_vec(myvla, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
		side_event_call(&my_provider_event_vla, side_arg_list(side_arg_vla(&myvla), side_arg_s64(42)));
	}
}

/* 1D array visitor */

struct app_visitor_ctx {
	const uint32_t *ptr;
	uint32_t length;
};

static
enum side_visitor_status test_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
{
	struct app_visitor_ctx *ctx = (struct app_visitor_ctx *) _ctx;
	uint32_t length = ctx->length, i;

	for (i = 0; i < length; i++) {
		const struct side_arg_vec elem = {
			.type = SIDE_TYPE_U32,
			.u = {
				.side_u32 = ctx->ptr[i],
			},
		};
		tracer_ctx->write_elem(tracer_ctx, &elem);
	}
	return SIDE_VISITOR_STATUS_OK;
}

static uint32_t testarray[] = { 1, 2, 3, 4, 5, 6, 7, 8 };

static side_define_event(my_provider_event_vla_visitor, "myprovider", "myvlavisit", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field_vla_visitor("vlavisit", side_elem_type(SIDE_TYPE_U32), test_visitor),
		side_field(SIDE_TYPE_S64, "v"),
	)
);

static
void test_vla_visitor(void)
{
	my_provider_event_vla_visitor.enabled = 1;
	side_event_cond(&my_provider_event_vla_visitor) {
		struct app_visitor_ctx ctx = {
			.ptr = testarray,
			.length = SIDE_ARRAY_SIZE(testarray),
		};
		side_event_call(&my_provider_event_vla_visitor, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
	}
}

/* 2D array visitor */

struct app_visitor_2d_inner_ctx {
	const uint32_t *ptr;
	uint32_t length;
};

static
enum side_visitor_status test_inner_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
{
	struct app_visitor_2d_inner_ctx *ctx = (struct app_visitor_2d_inner_ctx *) _ctx;
	uint32_t length = ctx->length, i;

	for (i = 0; i < length; i++) {
		const struct side_arg_vec elem = {
			.type = SIDE_TYPE_U32,
			.u = {
				.side_u32 = ctx->ptr[i],
			},
		};
		tracer_ctx->write_elem(tracer_ctx, &elem);
	}
	return SIDE_VISITOR_STATUS_OK;
}

struct app_visitor_2d_outer_ctx {
	const uint32_t (*ptr)[2];
	uint32_t length;
};

static
enum side_visitor_status test_outer_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
{
	struct app_visitor_2d_outer_ctx *ctx = (struct app_visitor_2d_outer_ctx *) _ctx;
	uint32_t length = ctx->length, i;

	for (i = 0; i < length; i++) {
		struct app_visitor_2d_inner_ctx inner_ctx = {
			.ptr = ctx->ptr[i],
			.length = 2,
		};
		const struct side_arg_vec elem = side_arg_vla_visitor(&inner_ctx);
		tracer_ctx->write_elem(tracer_ctx, &elem);
	}
	return SIDE_VISITOR_STATUS_OK;
}

static uint32_t testarray2d[][2] = {
	{ 1, 2 },
	{ 33, 44 },
	{ 55, 66 },
};

static side_define_event(my_provider_event_vla_visitor2d, "myprovider", "myvlavisit2d", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field_vla_visitor("vlavisit2d",
			side_elem(side_type_vla_visitor_decl(side_elem_type(SIDE_TYPE_U32), test_inner_visitor)), test_outer_visitor),
		side_field(SIDE_TYPE_S64, "v"),
	)
);

static
void test_vla_visitor_2d(void)
{
	my_provider_event_vla_visitor2d.enabled = 1;
	side_event_cond(&my_provider_event_vla_visitor2d) {
		struct app_visitor_2d_outer_ctx ctx = {
			.ptr = testarray2d,
			.length = SIDE_ARRAY_SIZE(testarray2d),
		};
		side_event_call(&my_provider_event_vla_visitor2d, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
	}
}

static int64_t array_fixint[] = { -444, 555, 123, 2897432587 };

static side_define_event(my_provider_event_array_fixint, "myprovider", "myarrayfixint", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field_array("arrfixint", side_elem_type(SIDE_TYPE_S64), SIDE_ARRAY_SIZE(array_fixint)),
		side_field(SIDE_TYPE_S64, "v"),
	)
);

static
void test_array_fixint(void)
{
	my_provider_event_array_fixint.enabled = 1;
	side_event(&my_provider_event_array_fixint,
		side_arg_list(side_arg_array_s64(array_fixint), side_arg_s64(42)));
}

static int64_t vla_fixint[] = { -444, 555, 123, 2897432587 };

static side_define_event(my_provider_event_vla_fixint, "myprovider", "myvlafixint", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field_vla("vlafixint", side_elem_type(SIDE_TYPE_S64)),
		side_field(SIDE_TYPE_S64, "v"),
	)
);

static
void test_vla_fixint(void)
{
	my_provider_event_vla_fixint.enabled = 1;
	side_event(&my_provider_event_vla_fixint,
		side_arg_list(side_arg_vla_s64(vla_fixint, SIDE_ARRAY_SIZE(vla_fixint)), side_arg_s64(42)));
}

static side_define_event(my_provider_event_dynamic_basic,
	"myprovider", "mydynamicbasic", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	)
);

static
void test_dynamic_basic_type(void)
{
	my_provider_event_dynamic_basic.enabled = 1;
	side_event(&my_provider_event_dynamic_basic,
		side_arg_list(side_arg_dynamic(side_arg_dynamic_s16(-33))));
}

static side_define_event(my_provider_event_dynamic_vla,
	"myprovider", "mydynamicvla", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	)
);

static
void test_dynamic_vla(void)
{
	side_arg_dynamic_define_vec(myvla, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));

	my_provider_event_dynamic_vla.enabled = 1;
	side_event(&my_provider_event_dynamic_vla,
		side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
}

static side_define_event(my_provider_event_dynamic_null,
	"myprovider", "mydynamicnull", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	)
);

static
void test_dynamic_null(void)
{
	my_provider_event_dynamic_null.enabled = 1;
	side_event(&my_provider_event_dynamic_null,
		side_arg_list(side_arg_dynamic(side_arg_dynamic_null())));
}

static side_define_event(my_provider_event_dynamic_map,
	"myprovider", "mydynamicmap", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	)
);

static
void test_dynamic_map(void)
{
	side_arg_dynamic_define_map(mymap,
		side_arg_list(
			side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
			side_arg_dynamic_field("b", side_arg_dynamic_string("zzz")),
			side_arg_dynamic_field("c", side_arg_dynamic_null())
		)
	);

	my_provider_event_dynamic_map.enabled = 1;
	side_event(&my_provider_event_dynamic_map,
		side_arg_list(side_arg_dynamic(side_arg_dynamic_map(&mymap))));
}

int main()
{
	test_fields();
	test_struct();
	test_array();
	test_vla();
	test_vla_visitor();
	test_vla_visitor_2d();
	test_array_fixint();
	test_vla_fixint();
	test_dynamic_basic_type();
	test_dynamic_vla();
	test_dynamic_null();
	test_dynamic_map();
	return 0;
}
Commit	Line	Data
f611d0c3 MD	1	// SPDX-License-Identifier: MIT
	2	/*
	3	* Copyright 2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	4	*/
	5
	6	#include <stdint.h>
	7	#include <inttypes.h>
	8	#include <stdlib.h>
	9	#include <stdio.h>
	10
	11	#include <side/trace.h>
	12	#include "tracer.h"
	13
	14	/* User code example */
	15
	16	static side_define_event(my_provider_event, "myprovider", "myevent", SIDE_LOGLEVEL_DEBUG,
	17	side_field_list(
	18	side_field(SIDE_TYPE_U32, "abc"),
	19	side_field(SIDE_TYPE_S64, "def"),
	20	side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	21	)
	22	);
	23
	24	static
	25	void test_fields(void)
	26	{
	27	uint32_t uw = 42;
	28	int64_t sdw = -500;
	29
	30	my_provider_event.enabled = 1;
a2e2357e MD	31	side_event(&my_provider_event, side_arg_list(side_arg_u32(uw), side_arg_s64(sdw),
a2e2357e MD	32	side_arg_dynamic(side_arg_dynamic_string("zzz"))));
f611d0c3 MD	33	}
	34
	35	static side_define_event(my_provider_event2, "myprovider", "myevent2", SIDE_LOGLEVEL_DEBUG,
	36	side_field_list(
	37	side_field_struct("structfield",
	38	side_field_list(
	39	side_field(SIDE_TYPE_U32, "x"),
	40	side_field(SIDE_TYPE_S64, "y"),
	41	)
	42	),
	43	side_field(SIDE_TYPE_U8, "z"),
	44	)
	45	);
	46
	47	static
	48	void test_struct(void)
	49	{
	50	my_provider_event2.enabled = 1;
	51	side_event_cond(&my_provider_event2) {
	52	side_arg_define_vec(mystruct, side_arg_list(side_arg_u32(21), side_arg_s64(22)));
	53	side_event_call(&my_provider_event2, side_arg_list(side_arg_struct(&mystruct), side_arg_u8(55)));
	54	}
	55	}
	56
	57	static side_define_event(my_provider_event_array, "myprovider", "myarray", SIDE_LOGLEVEL_DEBUG,
	58	side_field_list(
cdd6e858	59	side_field_array("arr", side_elem_type(SIDE_TYPE_U32), 3),
f611d0c3 MD	60	side_field(SIDE_TYPE_S64, "v"),
	61	)
	62	);
	63
	64	static
	65	void test_array(void)
	66	{
	67	my_provider_event_array.enabled = 1;
	68	side_event_cond(&my_provider_event_array) {
	69	side_arg_define_vec(myarray, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
	70	side_event_call(&my_provider_event_array, side_arg_list(side_arg_array(&myarray), side_arg_s64(42)));
	71	}
	72	}
	73
	74	static side_define_event(my_provider_event_vla, "myprovider", "myvla", SIDE_LOGLEVEL_DEBUG,
	75	side_field_list(
cdd6e858	76	side_field_vla("vla", side_elem_type(SIDE_TYPE_U32)),
f611d0c3 MD	77	side_field(SIDE_TYPE_S64, "v"),
	78	)
	79	);
	80
	81	static
	82	void test_vla(void)
	83	{
	84	my_provider_event_vla.enabled = 1;
	85	side_event_cond(&my_provider_event_vla) {
	86	side_arg_define_vec(myvla, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
	87	side_event_call(&my_provider_event_vla, side_arg_list(side_arg_vla(&myvla), side_arg_s64(42)));
	88	}
	89	}
	90
cdd6e858 MD	91	/* 1D array visitor */
cdd6e858 MD	92
f611d0c3 MD	93	struct app_visitor_ctx {
f611d0c3 MD	94	const uint32_t *ptr;
352a4b77	95	uint32_t length;
f611d0c3 MD	96	};
f611d0c3 MD	97
352a4b77 MD	98	static
352a4b77 MD	99	enum side_visitor_status test_visitor(const struct side_tracer_visitor_ctx tracer_ctx, void _ctx)
f611d0c3 MD	100	{
f611d0c3 MD	101	struct app_visitor_ctx ctx = (struct app_visitor_ctx ) _ctx;
352a4b77 MD	102	uint32_t length = ctx->length, i;
	103
	104	for (i = 0; i < length; i++) {
	105	const struct side_arg_vec elem = {
	106	.type = SIDE_TYPE_U32,
	107	.u = {
	108	.side_u32 = ctx->ptr[i],
	109	},
	110	};
	111	tracer_ctx->write_elem(tracer_ctx, &elem);
	112	}
f611d0c3 MD	113	return SIDE_VISITOR_STATUS_OK;
	114	}
	115
	116	static uint32_t testarray[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
	117
	118	static side_define_event(my_provider_event_vla_visitor, "myprovider", "myvlavisit", SIDE_LOGLEVEL_DEBUG,
	119	side_field_list(
cdd6e858	120	side_field_vla_visitor("vlavisit", side_elem_type(SIDE_TYPE_U32), test_visitor),
f611d0c3 MD	121	side_field(SIDE_TYPE_S64, "v"),
	122	)
	123	);
	124
	125	static
	126	void test_vla_visitor(void)
	127	{
	128	my_provider_event_vla_visitor.enabled = 1;
	129	side_event_cond(&my_provider_event_vla_visitor) {
	130	struct app_visitor_ctx ctx = {
	131	.ptr = testarray,
352a4b77	132	.length = SIDE_ARRAY_SIZE(testarray),
f611d0c3 MD	133	};
	134	side_event_call(&my_provider_event_vla_visitor, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
	135	}
	136	}
	137
cdd6e858 MD	138	/* 2D array visitor */
	139
	140	struct app_visitor_2d_inner_ctx {
	141	const uint32_t *ptr;
	142	uint32_t length;
	143	};
	144
	145	static
	146	enum side_visitor_status test_inner_visitor(const struct side_tracer_visitor_ctx tracer_ctx, void _ctx)
	147	{
	148	struct app_visitor_2d_inner_ctx ctx = (struct app_visitor_2d_inner_ctx ) _ctx;
	149	uint32_t length = ctx->length, i;
	150
	151	for (i = 0; i < length; i++) {
	152	const struct side_arg_vec elem = {
	153	.type = SIDE_TYPE_U32,
	154	.u = {
	155	.side_u32 = ctx->ptr[i],
	156	},
	157	};
	158	tracer_ctx->write_elem(tracer_ctx, &elem);
	159	}
	160	return SIDE_VISITOR_STATUS_OK;
	161	}
	162
	163	struct app_visitor_2d_outer_ctx {
	164	const uint32_t (*ptr)[2];
	165	uint32_t length;
	166	};
	167
	168	static
	169	enum side_visitor_status test_outer_visitor(const struct side_tracer_visitor_ctx tracer_ctx, void _ctx)
	170	{
	171	struct app_visitor_2d_outer_ctx ctx = (struct app_visitor_2d_outer_ctx ) _ctx;
	172	uint32_t length = ctx->length, i;
	173
	174	for (i = 0; i < length; i++) {
	175	struct app_visitor_2d_inner_ctx inner_ctx = {
	176	.ptr = ctx->ptr[i],
	177	.length = 2,
	178	};
	179	const struct side_arg_vec elem = side_arg_vla_visitor(&inner_ctx);
	180	tracer_ctx->write_elem(tracer_ctx, &elem);
	181	}
	182	return SIDE_VISITOR_STATUS_OK;
	183	}
	184
	185	static uint32_t testarray2d[][2] = {
	186	{ 1, 2 },
	187	{ 33, 44 },
	188	{ 55, 66 },
	189	};
	190
	191	static side_define_event(my_provider_event_vla_visitor2d, "myprovider", "myvlavisit2d", SIDE_LOGLEVEL_DEBUG,
	192	side_field_list(
	193	side_field_vla_visitor("vlavisit2d",
	194	side_elem(side_type_vla_visitor_decl(side_elem_type(SIDE_TYPE_U32), test_inner_visitor)), test_outer_visitor),
	195	side_field(SIDE_TYPE_S64, "v"),
	196	)
	197	);
	198
	199	static
	200	void test_vla_visitor_2d(void)
	201	{
202	my_provider_event_vla_visitor2d.enabled = 1;
203	side_event_cond(&my_provider_event_vla_visitor2d) {
204	struct app_visitor_2d_outer_ctx ctx = {
205	.ptr = testarray2d,
206	.length = SIDE_ARRAY_SIZE(testarray2d),
207	};
208	side_event_call(&my_provider_event_vla_visitor2d, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
209	}
210	}
211
ba845af5 MD	212	static int64_t array_fixint[] = { -444, 555, 123, 2897432587 };
	213
	214	static side_define_event(my_provider_event_array_fixint, "myprovider", "myarrayfixint", SIDE_LOGLEVEL_DEBUG,
	215	side_field_list(
cdd6e858	216	side_field_array("arrfixint", side_elem_type(SIDE_TYPE_S64), SIDE_ARRAY_SIZE(array_fixint)),
ba845af5 MD	217	side_field(SIDE_TYPE_S64, "v"),
	218	)
	219	);
	220
	221	static
	222	void test_array_fixint(void)
	223	{
	224	my_provider_event_array_fixint.enabled = 1;
1533629f MD	225	side_event(&my_provider_event_array_fixint,
	226	side_arg_list(side_arg_array_s64(array_fixint), side_arg_s64(42)));
	227	}
	228
	229	static int64_t vla_fixint[] = { -444, 555, 123, 2897432587 };
	230
	231	static side_define_event(my_provider_event_vla_fixint, "myprovider", "myvlafixint", SIDE_LOGLEVEL_DEBUG,
	232	side_field_list(
cdd6e858	233	side_field_vla("vlafixint", side_elem_type(SIDE_TYPE_S64)),
1533629f MD	234	side_field(SIDE_TYPE_S64, "v"),
	235	)
	236	);
	237
	238	static
	239	void test_vla_fixint(void)
	240	{
	241	my_provider_event_vla_fixint.enabled = 1;
	242	side_event(&my_provider_event_vla_fixint,
	243	side_arg_list(side_arg_vla_s64(vla_fixint, SIDE_ARRAY_SIZE(vla_fixint)), side_arg_s64(42)));
ba845af5 MD	244	}
ba845af5 MD	245
a2e2357e MD	246	static side_define_event(my_provider_event_dynamic_basic,
	247	"myprovider", "mydynamicbasic", SIDE_LOGLEVEL_DEBUG,
	248	side_field_list(
	249	side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	250	)
	251	);
	252
	253	static
	254	void test_dynamic_basic_type(void)
	255	{
	256	my_provider_event_dynamic_basic.enabled = 1;
	257	side_event(&my_provider_event_dynamic_basic,
	258	side_arg_list(side_arg_dynamic(side_arg_dynamic_s16(-33))));
	259	}
	260
	261	static side_define_event(my_provider_event_dynamic_vla,
	262	"myprovider", "mydynamicvla", SIDE_LOGLEVEL_DEBUG,
	263	side_field_list(
	264	side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	265	)
	266	);
	267
	268	static
	269	void test_dynamic_vla(void)
	270	{
	271	side_arg_dynamic_define_vec(myvla, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
	272
	273	my_provider_event_dynamic_vla.enabled = 1;
	274	side_event(&my_provider_event_dynamic_vla,
	275	side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
	276	}
	277
465e5e7e MD	278	static side_define_event(my_provider_event_dynamic_null,
	279	"myprovider", "mydynamicnull", SIDE_LOGLEVEL_DEBUG,
	280	side_field_list(
	281	side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	282	)
	283	);
	284
	285	static
	286	void test_dynamic_null(void)
	287	{
	288	my_provider_event_dynamic_null.enabled = 1;
	289	side_event(&my_provider_event_dynamic_null,
	290	side_arg_list(side_arg_dynamic(side_arg_dynamic_null())));
	291	}
	292
	293	static side_define_event(my_provider_event_dynamic_map,
	294	"myprovider", "mydynamicmap", SIDE_LOGLEVEL_DEBUG,
	295	side_field_list(
	296	side_field(SIDE_TYPE_DYNAMIC, "dynamic"),
	297	)
	298	);
	299
	300	static
	301	void test_dynamic_map(void)
	302	{
	303	side_arg_dynamic_define_map(mymap,
	304	side_arg_list(
	305	side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
	306	side_arg_dynamic_field("b", side_arg_dynamic_string("zzz")),
	307	side_arg_dynamic_field("c", side_arg_dynamic_null())
	308	)
	309	);
	310
	311	my_provider_event_dynamic_map.enabled = 1;
	312	side_event(&my_provider_event_dynamic_map,
	313	side_arg_list(side_arg_dynamic(side_arg_dynamic_map(&mymap))));
	314	}
	315
f611d0c3 MD	316	int main()
	317	{
	318	test_fields();
	319	test_struct();
	320	test_array();
	321	test_vla();
	322	test_vla_visitor();
cdd6e858	323	test_vla_visitor_2d();
ba845af5	324	test_array_fixint();
1533629f	325	test_vla_fixint();
a2e2357e MD	326	test_dynamic_basic_type();
a2e2357e MD	327	test_dynamic_vla();
465e5e7e MD	328	test_dynamic_null();
465e5e7e MD	329	test_dynamic_map();
f611d0c3 MD	330	return 0;
f611d0c3 MD	331	}