[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("abc", SIDE_TYPE_U32),
		side_field("def", SIDE_TYPE_S64),
		side_field("dynamic", SIDE_TYPE_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("x", SIDE_TYPE_U32),
				side_field("y", SIDE_TYPE_S64),
			)
		),
		side_field("z", SIDE_TYPE_U8),
	)
);

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("v", SIDE_TYPE_S64),
	)
);

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("v", SIDE_TYPE_S64),
	)
);

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],
			},
		};
		if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
			return SIDE_VISITOR_STATUS_ERROR;
	}
	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("v", SIDE_TYPE_S64),
	)
);

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],
			},
		};
		if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
			return SIDE_VISITOR_STATUS_ERROR;
	}
	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);
		if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
			return SIDE_VISITOR_STATUS_ERROR;
	}
	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("v", SIDE_TYPE_S64),
	)
);

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("v", SIDE_TYPE_S64),
	)
);

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("v", SIDE_TYPE_S64),
	)
);

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("dynamic", SIDE_TYPE_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("dynamic", SIDE_TYPE_DYNAMIC),
	)
);

static
void test_dynamic_vla(void)
{
	side_arg_dynamic_define_vec(myvla,
		side_arg_list(
			side_arg_dynamic_u32(1), side_arg_dynamic_u32(2), side_arg_dynamic_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("dynamic", SIDE_TYPE_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_struct,
	"myprovider", "mydynamicstruct", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field("dynamic", SIDE_TYPE_DYNAMIC),
	)
);

static
void test_dynamic_struct(void)
{
	side_arg_dynamic_define_struct(mystruct,
		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_struct.enabled = 1;
	side_event(&my_provider_event_dynamic_struct,
		side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
}

static side_define_event(my_provider_event_dynamic_nested_struct,
	"myprovider", "mydynamicnestedstruct", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field("dynamic", SIDE_TYPE_DYNAMIC),
	)
);

static
void test_dynamic_nested_struct(void)
{
	side_arg_dynamic_define_struct(nested,
		side_arg_list(
			side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
			side_arg_dynamic_field("b", side_arg_dynamic_u8(55)),
		)
	);
	side_arg_dynamic_define_struct(nested2,
		side_arg_list(
			side_arg_dynamic_field("aa", side_arg_dynamic_u64(128)),
			side_arg_dynamic_field("bb", side_arg_dynamic_u16(1)),
		)
	);
	side_arg_dynamic_define_struct(mystruct,
		side_arg_list(
			side_arg_dynamic_field("nested", side_arg_dynamic_struct(&nested)),
			side_arg_dynamic_field("nested2", side_arg_dynamic_struct(&nested2)),
		)
	);
	my_provider_event_dynamic_nested_struct.enabled = 1;
	side_event(&my_provider_event_dynamic_nested_struct,
		side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
}

static side_define_event(my_provider_event_dynamic_vla_struct,
	"myprovider", "mydynamicvlastruct", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field("dynamic", SIDE_TYPE_DYNAMIC),
	)
);

static
void test_dynamic_vla_struct(void)
{
	side_arg_dynamic_define_struct(nested,
		side_arg_list(
			side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
			side_arg_dynamic_field("b", side_arg_dynamic_u8(55)),
		)
	);
	side_arg_dynamic_define_vec(myvla,
		side_arg_list(
			side_arg_dynamic_struct(&nested),
			side_arg_dynamic_struct(&nested),
			side_arg_dynamic_struct(&nested),
			side_arg_dynamic_struct(&nested),
		)
	);
	my_provider_event_dynamic_vla_struct.enabled = 1;
	side_event(&my_provider_event_dynamic_vla_struct,
		side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
}

static side_define_event(my_provider_event_dynamic_struct_vla,
	"myprovider", "mydynamicstructvla", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field("dynamic", SIDE_TYPE_DYNAMIC),
	)
);

static
void test_dynamic_struct_vla(void)
{
	side_arg_dynamic_define_vec(myvla,
		side_arg_list(
			side_arg_dynamic_u32(1), side_arg_dynamic_u32(2), side_arg_dynamic_u32(3),
		)
	);
	side_arg_dynamic_define_vec(myvla2,
		side_arg_list(
			side_arg_dynamic_u32(4), side_arg_dynamic_u64(5), side_arg_dynamic_u32(6),
		)
	);
	side_arg_dynamic_define_struct(mystruct,
		side_arg_list(
			side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla)),
			side_arg_dynamic_field("b", side_arg_dynamic_vla(&myvla2)),
		)
	);
	my_provider_event_dynamic_struct_vla.enabled = 1;
	side_event(&my_provider_event_dynamic_struct_vla,
		side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
}

static side_define_event(my_provider_event_dynamic_nested_vla,
	"myprovider", "mydynamicnestedvla", SIDE_LOGLEVEL_DEBUG,
	side_field_list(
		side_field("dynamic", SIDE_TYPE_DYNAMIC),
	)
);

static
void test_dynamic_nested_vla(void)
{
	side_arg_dynamic_define_vec(nestedvla,
		side_arg_list(
			side_arg_dynamic_u32(1), side_arg_dynamic_u16(2), side_arg_dynamic_u32(3),
		)
	);
	side_arg_dynamic_define_vec(nestedvla2,
		side_arg_list(
			side_arg_dynamic_u8(4), side_arg_dynamic_u32(5), side_arg_dynamic_u32(6),
		)
	);
	side_arg_dynamic_define_vec(myvla,
		side_arg_list(
			side_arg_dynamic_vla(&nestedvla),
			side_arg_dynamic_vla(&nestedvla2),
		)
	);
	my_provider_event_dynamic_nested_vla.enabled = 1;
	side_event(&my_provider_event_dynamic_nested_vla,
		side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
}

static side_define_event(my_provider_event_variadic,
	"myprovider", "myvariadicevent", SIDE_LOGLEVEL_DEBUG,
	side_field_list()
);

static
void test_variadic(void)
{
	my_provider_event_variadic.enabled = 1;
	side_event_variadic(&my_provider_event_variadic,
		side_arg_list(),
		side_arg_list(
			side_arg_dynamic_field("a", side_arg_dynamic_u32(55)),
			side_arg_dynamic_field("b", side_arg_dynamic_s8(-4)),
		)
	);
}

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_struct();
	test_dynamic_nested_struct();
	test_dynamic_vla_struct();
	test_dynamic_struct_vla();
	test_dynamic_nested_vla();
	test_variadic();
	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(
91d140a6 MD	18	side_field("abc", SIDE_TYPE_U32),
	19	side_field("def", SIDE_TYPE_S64),
	20	side_field("dynamic", SIDE_TYPE_DYNAMIC),
f611d0c3 MD	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(
91d140a6 MD	39	side_field("x", SIDE_TYPE_U32),
91d140a6 MD	40	side_field("y", SIDE_TYPE_S64),
f611d0c3 MD	41	)
f611d0c3 MD	42	),
91d140a6	43	side_field("z", SIDE_TYPE_U8),
f611d0c3 MD	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),
91d140a6	60	side_field("v", SIDE_TYPE_S64),
f611d0c3 MD	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)),
91d140a6	77	side_field("v", SIDE_TYPE_S64),
f611d0c3 MD	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	};
db6ecef9 MD	111	if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
db6ecef9 MD	112	return SIDE_VISITOR_STATUS_ERROR;
352a4b77	113	}
f611d0c3 MD	114	return SIDE_VISITOR_STATUS_OK;
	115	}
	116
	117	static uint32_t testarray[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
	118
	119	static side_define_event(my_provider_event_vla_visitor, "myprovider", "myvlavisit", SIDE_LOGLEVEL_DEBUG,
	120	side_field_list(
cdd6e858	121	side_field_vla_visitor("vlavisit", side_elem_type(SIDE_TYPE_U32), test_visitor),
91d140a6	122	side_field("v", SIDE_TYPE_S64),
f611d0c3 MD	123	)
	124	);
	125
	126	static
	127	void test_vla_visitor(void)
	128	{
	129	my_provider_event_vla_visitor.enabled = 1;
	130	side_event_cond(&my_provider_event_vla_visitor) {
	131	struct app_visitor_ctx ctx = {
	132	.ptr = testarray,
352a4b77	133	.length = SIDE_ARRAY_SIZE(testarray),
f611d0c3 MD	134	};
	135	side_event_call(&my_provider_event_vla_visitor, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
	136	}
	137	}
	138
cdd6e858 MD	139	/* 2D array visitor */
	140
	141	struct app_visitor_2d_inner_ctx {
	142	const uint32_t *ptr;
	143	uint32_t length;
	144	};
	145
	146	static
	147	enum side_visitor_status test_inner_visitor(const struct side_tracer_visitor_ctx tracer_ctx, void _ctx)
	148	{
	149	struct app_visitor_2d_inner_ctx ctx = (struct app_visitor_2d_inner_ctx ) _ctx;
	150	uint32_t length = ctx->length, i;
	151
	152	for (i = 0; i < length; i++) {
	153	const struct side_arg_vec elem = {
	154	.type = SIDE_TYPE_U32,
	155	.u = {
	156	.side_u32 = ctx->ptr[i],
	157	},
	158	};
db6ecef9 MD	159	if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
db6ecef9 MD	160	return SIDE_VISITOR_STATUS_ERROR;
cdd6e858 MD	161	}
	162	return SIDE_VISITOR_STATUS_OK;
	163	}
	164
	165	struct app_visitor_2d_outer_ctx {
	166	const uint32_t (*ptr)[2];
	167	uint32_t length;
	168	};
	169
	170	static
	171	enum side_visitor_status test_outer_visitor(const struct side_tracer_visitor_ctx tracer_ctx, void _ctx)
	172	{
	173	struct app_visitor_2d_outer_ctx ctx = (struct app_visitor_2d_outer_ctx ) _ctx;
	174	uint32_t length = ctx->length, i;
	175
	176	for (i = 0; i < length; i++) {
	177	struct app_visitor_2d_inner_ctx inner_ctx = {
	178	.ptr = ctx->ptr[i],
	179	.length = 2,
	180	};
	181	const struct side_arg_vec elem = side_arg_vla_visitor(&inner_ctx);
db6ecef9 MD	182	if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
db6ecef9 MD	183	return SIDE_VISITOR_STATUS_ERROR;
cdd6e858 MD	184	}
	185	return SIDE_VISITOR_STATUS_OK;
	186	}
	187
	188	static uint32_t testarray2d[][2] = {
	189	{ 1, 2 },
	190	{ 33, 44 },
	191	{ 55, 66 },
	192	};
	193
	194	static side_define_event(my_provider_event_vla_visitor2d, "myprovider", "myvlavisit2d", SIDE_LOGLEVEL_DEBUG,
	195	side_field_list(
	196	side_field_vla_visitor("vlavisit2d",
	197	side_elem(side_type_vla_visitor_decl(side_elem_type(SIDE_TYPE_U32), test_inner_visitor)), test_outer_visitor),
91d140a6	198	side_field("v", SIDE_TYPE_S64),
cdd6e858 MD	199	)
	200	);
	201
	202	static
	203	void test_vla_visitor_2d(void)
	204	{
	205	my_provider_event_vla_visitor2d.enabled = 1;
	206	side_event_cond(&my_provider_event_vla_visitor2d) {
	207	struct app_visitor_2d_outer_ctx ctx = {
	208	.ptr = testarray2d,
	209	.length = SIDE_ARRAY_SIZE(testarray2d),
	210	};
	211	side_event_call(&my_provider_event_vla_visitor2d, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
	212	}
	213	}
	214
ba845af5 MD	215	static int64_t array_fixint[] = { -444, 555, 123, 2897432587 };
	216
	217	static side_define_event(my_provider_event_array_fixint, "myprovider", "myarrayfixint", SIDE_LOGLEVEL_DEBUG,
	218	side_field_list(
cdd6e858	219	side_field_array("arrfixint", side_elem_type(SIDE_TYPE_S64), SIDE_ARRAY_SIZE(array_fixint)),
91d140a6	220	side_field("v", SIDE_TYPE_S64),
ba845af5 MD	221	)
	222	);
	223
	224	static
	225	void test_array_fixint(void)
	226	{
	227	my_provider_event_array_fixint.enabled = 1;
1533629f MD	228	side_event(&my_provider_event_array_fixint,
	229	side_arg_list(side_arg_array_s64(array_fixint), side_arg_s64(42)));
	230	}
	231
	232	static int64_t vla_fixint[] = { -444, 555, 123, 2897432587 };
	233
	234	static side_define_event(my_provider_event_vla_fixint, "myprovider", "myvlafixint", SIDE_LOGLEVEL_DEBUG,
	235	side_field_list(
cdd6e858	236	side_field_vla("vlafixint", side_elem_type(SIDE_TYPE_S64)),
91d140a6	237	side_field("v", SIDE_TYPE_S64),
1533629f MD	238	)
	239	);
	240
	241	static
	242	void test_vla_fixint(void)
	243	{
	244	my_provider_event_vla_fixint.enabled = 1;
	245	side_event(&my_provider_event_vla_fixint,
	246	side_arg_list(side_arg_vla_s64(vla_fixint, SIDE_ARRAY_SIZE(vla_fixint)), side_arg_s64(42)));
ba845af5 MD	247	}
ba845af5 MD	248
a2e2357e MD	249	static side_define_event(my_provider_event_dynamic_basic,
	250	"myprovider", "mydynamicbasic", SIDE_LOGLEVEL_DEBUG,
	251	side_field_list(
91d140a6	252	side_field("dynamic", SIDE_TYPE_DYNAMIC),
a2e2357e MD	253	)
	254	);
	255
	256	static
	257	void test_dynamic_basic_type(void)
	258	{
	259	my_provider_event_dynamic_basic.enabled = 1;
	260	side_event(&my_provider_event_dynamic_basic,
	261	side_arg_list(side_arg_dynamic(side_arg_dynamic_s16(-33))));
	262	}
	263
	264	static side_define_event(my_provider_event_dynamic_vla,
	265	"myprovider", "mydynamicvla", SIDE_LOGLEVEL_DEBUG,
	266	side_field_list(
91d140a6	267	side_field("dynamic", SIDE_TYPE_DYNAMIC),
a2e2357e MD	268	)
	269	);
	270
	271	static
	272	void test_dynamic_vla(void)
	273	{
948e3e72 MD	274	side_arg_dynamic_define_vec(myvla,
948e3e72 MD	275	side_arg_list(
df075fa5 MD	276	side_arg_dynamic_u32(1), side_arg_dynamic_u32(2), side_arg_dynamic_u32(3),
	277	)
	278	);
a2e2357e MD	279	my_provider_event_dynamic_vla.enabled = 1;
	280	side_event(&my_provider_event_dynamic_vla,
	281	side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
	282	}
	283
465e5e7e MD	284	static side_define_event(my_provider_event_dynamic_null,
	285	"myprovider", "mydynamicnull", SIDE_LOGLEVEL_DEBUG,
	286	side_field_list(
91d140a6	287	side_field("dynamic", SIDE_TYPE_DYNAMIC),
465e5e7e MD	288	)
	289	);
	290
	291	static
	292	void test_dynamic_null(void)
	293	{
	294	my_provider_event_dynamic_null.enabled = 1;
	295	side_event(&my_provider_event_dynamic_null,
	296	side_arg_list(side_arg_dynamic(side_arg_dynamic_null())));
	297	}
	298
c208889e MD	299	static side_define_event(my_provider_event_dynamic_struct,
c208889e MD	300	"myprovider", "mydynamicstruct", SIDE_LOGLEVEL_DEBUG,
465e5e7e	301	side_field_list(
91d140a6	302	side_field("dynamic", SIDE_TYPE_DYNAMIC),
465e5e7e MD	303	)
	304	);
	305
	306	static
c208889e	307	void test_dynamic_struct(void)
465e5e7e	308	{
c208889e	309	side_arg_dynamic_define_struct(mystruct,
465e5e7e MD	310	side_arg_list(
	311	side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
	312	side_arg_dynamic_field("b", side_arg_dynamic_string("zzz")),
10c126ee	313	side_arg_dynamic_field("c", side_arg_dynamic_null()),
465e5e7e MD	314	)
	315	);
	316
c208889e MD	317	my_provider_event_dynamic_struct.enabled = 1;
	318	side_event(&my_provider_event_dynamic_struct,
	319	side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
465e5e7e MD	320	}
465e5e7e MD	321
c208889e MD	322	static side_define_event(my_provider_event_dynamic_nested_struct,
c208889e MD	323	"myprovider", "mydynamicnestedstruct", SIDE_LOGLEVEL_DEBUG,
3222d397	324	side_field_list(
91d140a6	325	side_field("dynamic", SIDE_TYPE_DYNAMIC),
3222d397 MD	326	)
	327	);
	328
	329	static
c208889e	330	void test_dynamic_nested_struct(void)
3222d397	331	{
c208889e	332	side_arg_dynamic_define_struct(nested,
3222d397 MD	333	side_arg_list(
	334	side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
	335	side_arg_dynamic_field("b", side_arg_dynamic_u8(55)),
	336	)
	337	);
c208889e	338	side_arg_dynamic_define_struct(nested2,
3222d397 MD	339	side_arg_list(
	340	side_arg_dynamic_field("aa", side_arg_dynamic_u64(128)),
	341	side_arg_dynamic_field("bb", side_arg_dynamic_u16(1)),
	342	)
	343	);
c208889e	344	side_arg_dynamic_define_struct(mystruct,
3222d397	345	side_arg_list(
c208889e MD	346	side_arg_dynamic_field("nested", side_arg_dynamic_struct(&nested)),
c208889e MD	347	side_arg_dynamic_field("nested2", side_arg_dynamic_struct(&nested2)),
3222d397 MD	348	)
3222d397 MD	349	);
c208889e MD	350	my_provider_event_dynamic_nested_struct.enabled = 1;
	351	side_event(&my_provider_event_dynamic_nested_struct,
	352	side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
3222d397 MD	353	}
3222d397 MD	354
c208889e MD	355	static side_define_event(my_provider_event_dynamic_vla_struct,
c208889e MD	356	"myprovider", "mydynamicvlastruct", SIDE_LOGLEVEL_DEBUG,
7ce1b78f	357	side_field_list(
91d140a6	358	side_field("dynamic", SIDE_TYPE_DYNAMIC),
7ce1b78f MD	359	)
	360	);
	361
	362	static
c208889e	363	void test_dynamic_vla_struct(void)
7ce1b78f	364	{
c208889e	365	side_arg_dynamic_define_struct(nested,
7ce1b78f MD	366	side_arg_list(
	367	side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
	368	side_arg_dynamic_field("b", side_arg_dynamic_u8(55)),
	369	)
	370	);
	371	side_arg_dynamic_define_vec(myvla,
	372	side_arg_list(
c208889e MD	373	side_arg_dynamic_struct(&nested),
	374	side_arg_dynamic_struct(&nested),
	375	side_arg_dynamic_struct(&nested),
	376	side_arg_dynamic_struct(&nested),
7ce1b78f MD	377	)
7ce1b78f MD	378	);
c208889e MD	379	my_provider_event_dynamic_vla_struct.enabled = 1;
c208889e MD	380	side_event(&my_provider_event_dynamic_vla_struct,
7ce1b78f MD	381	side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
	382	}
	383
c208889e MD	384	static side_define_event(my_provider_event_dynamic_struct_vla,
c208889e MD	385	"myprovider", "mydynamicstructvla", SIDE_LOGLEVEL_DEBUG,
980bfdc4	386	side_field_list(
91d140a6	387	side_field("dynamic", SIDE_TYPE_DYNAMIC),
980bfdc4 MD	388	)
	389	);
	390
	391	static
c208889e	392	void test_dynamic_struct_vla(void)
980bfdc4 MD	393	{
980bfdc4 MD	394	side_arg_dynamic_define_vec(myvla,
948e3e72	395	side_arg_list(
df075fa5 MD	396	side_arg_dynamic_u32(1), side_arg_dynamic_u32(2), side_arg_dynamic_u32(3),
	397	)
	398	);
980bfdc4	399	side_arg_dynamic_define_vec(myvla2,
948e3e72	400	side_arg_list(
df075fa5 MD	401	side_arg_dynamic_u32(4), side_arg_dynamic_u64(5), side_arg_dynamic_u32(6),
	402	)
	403	);
c208889e	404	side_arg_dynamic_define_struct(mystruct,
980bfdc4 MD	405	side_arg_list(
	406	side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla)),
	407	side_arg_dynamic_field("b", side_arg_dynamic_vla(&myvla2)),
	408	)
	409	);
c208889e MD	410	my_provider_event_dynamic_struct_vla.enabled = 1;
	411	side_event(&my_provider_event_dynamic_struct_vla,
	412	side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
980bfdc4 MD	413	}
980bfdc4 MD	414
948e3e72 MD	415	static side_define_event(my_provider_event_dynamic_nested_vla,
	416	"myprovider", "mydynamicnestedvla", SIDE_LOGLEVEL_DEBUG,
	417	side_field_list(
91d140a6	418	side_field("dynamic", SIDE_TYPE_DYNAMIC),
948e3e72 MD	419	)
	420	);
	421
	422	static
	423	void test_dynamic_nested_vla(void)
	424	{
	425	side_arg_dynamic_define_vec(nestedvla,
	426	side_arg_list(
	427	side_arg_dynamic_u32(1), side_arg_dynamic_u16(2), side_arg_dynamic_u32(3),
	428	)
	429	);
	430	side_arg_dynamic_define_vec(nestedvla2,
	431	side_arg_list(
	432	side_arg_dynamic_u8(4), side_arg_dynamic_u32(5), side_arg_dynamic_u32(6),
	433	)
	434	);
	435	side_arg_dynamic_define_vec(myvla,
	436	side_arg_list(
	437	side_arg_dynamic_vla(&nestedvla),
	438	side_arg_dynamic_vla(&nestedvla2),
	439	)
	440	);
	441	my_provider_event_dynamic_nested_vla.enabled = 1;
	442	side_event(&my_provider_event_dynamic_nested_vla,
	443	side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
	444	}
	445
19fa6aa2 MD	446	static side_define_event(my_provider_event_variadic,
	447	"myprovider", "myvariadicevent", SIDE_LOGLEVEL_DEBUG,
	448	side_field_list()
	449	);
	450
	451	static
	452	void test_variadic(void)
	453	{
	454	my_provider_event_variadic.enabled = 1;
	455	side_event_variadic(&my_provider_event_variadic,
	456	side_arg_list(),
	457	side_arg_list(
	458	side_arg_dynamic_field("a", side_arg_dynamic_u32(55)),
	459	side_arg_dynamic_field("b", side_arg_dynamic_s8(-4)),
	460	)
	461	);
	462	}
	463
f611d0c3 MD	464	int main()
	465	{
	466	test_fields();
	467	test_struct();
	468	test_array();
	469	test_vla();
	470	test_vla_visitor();
cdd6e858	471	test_vla_visitor_2d();
ba845af5	472	test_array_fixint();
1533629f	473	test_vla_fixint();
a2e2357e MD	474	test_dynamic_basic_type();
a2e2357e MD	475	test_dynamic_vla();
465e5e7e	476	test_dynamic_null();
c208889e MD	477	test_dynamic_struct();
	478	test_dynamic_nested_struct();
	479	test_dynamic_vla_struct();
	480	test_dynamic_struct_vla();
948e3e72	481	test_dynamic_nested_vla();
19fa6aa2	482	test_variadic();
f611d0c3 MD	483	return 0;
f611d0c3 MD	484	}