src/test.c

   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 #include <stdbool.h>
  11
  12 #include <side/trace.h>
  13 #include "tracer.h"
  14
  15 /* User code example */
  16
  17 side_static_event(my_provider_event, "myprovider", "myevent", SIDE_LOGLEVEL_DEBUG,
  18         side_field_list(
  19                 side_field_u32("abc", side_attr_list()),
  20                 side_field_s64("def", side_attr_list()),
  21                 side_field_dynamic("dynamic", side_attr_list()),
  22         ),
  23         side_attr_list()
  24 );
  25
  26 static
  27 void test_fields(void)
  28 {
  29         uint32_t uw = 42;
  30         int64_t sdw = -500;
  31
  32         side_event_enable__my_provider_event = 1;
  33         side_event(my_provider_event, side_arg_list(side_arg_u32(uw), side_arg_s64(sdw),
  34                 side_arg_dynamic(side_arg_dynamic_string("zzz", side_attr_list()))));
  35 }
  36
  37 side_hidden_event(my_provider_event_hidden, "myprovider", "myeventhidden", SIDE_LOGLEVEL_DEBUG,
  38         side_field_list(
  39                 side_field_u32("abc", side_attr_list()),
  40         ),
  41         side_attr_list()
  42 );
  43
  44 static
  45 void test_event_hidden(void)
  46 {
  47         side_event_enable__my_provider_event_hidden = 1;
  48         side_event(my_provider_event_hidden, side_arg_list(side_arg_u32(2)));
  49 }
  50
  51 side_declare_event(my_provider_event_export);
  52
  53 side_export_event(my_provider_event_export, "myprovider", "myeventexport", SIDE_LOGLEVEL_DEBUG,
  54         side_field_list(
  55                 side_field_u32("abc", side_attr_list()),
  56         ),
  57         side_attr_list()
  58 );
  59
  60 static
  61 void test_event_export(void)
  62 {
  63         side_event_enable__my_provider_event_export = 1;
  64         side_event(my_provider_event_export, side_arg_list(side_arg_u32(2)));
  65 }
  66
  67 side_static_event(my_provider_event_struct_literal, "myprovider", "myeventstructliteral", SIDE_LOGLEVEL_DEBUG,
  68         side_field_list(
  69                 side_field_struct("structliteral",
  70                         side_struct_literal(
  71                                 side_field_list(
  72                                         side_field_u32("x", side_attr_list()),
  73                                         side_field_s64("y", side_attr_list()),
  74                                 ),
  75                                 side_attr_list()
  76                         )
  77                 ),
  78                 side_field_u8("z", side_attr_list()),
  79         ),
  80         side_attr_list()
  81 );
  82
  83 static
  84 void test_struct_literal(void)
  85 {
  86         side_event_enable__my_provider_event_struct_literal = 1;
  87         side_event_cond(my_provider_event_struct_literal) {
  88                 side_arg_define_vec(mystruct, side_arg_list(side_arg_u32(21), side_arg_s64(22)));
  89                 side_event_call(my_provider_event_struct_literal, side_arg_list(side_arg_struct(&mystruct), side_arg_u8(55)));
  90         }
  91 }
  92
  93 static side_define_struct(mystructdef,
  94         side_field_list(
  95                 side_field_u32("x", side_attr_list()),
  96                 side_field_s64("y", side_attr_list()),
  97         ),
  98         side_attr_list()
  99 );
 100
 101 side_static_event(my_provider_event_struct, "myprovider", "myeventstruct", SIDE_LOGLEVEL_DEBUG,
 102         side_field_list(
 103                 side_field_struct("struct", &mystructdef),
 104                 side_field_u8("z", side_attr_list()),
 105         ),
 106         side_attr_list()
 107 );
 108
 109 static
 110 void test_struct(void)
 111 {
 112         side_event_enable__my_provider_event_struct = 1;
 113         side_event_cond(my_provider_event_struct) {
 114                 side_arg_define_vec(mystruct, side_arg_list(side_arg_u32(21), side_arg_s64(22)));
 115                 side_event_call(my_provider_event_struct, side_arg_list(side_arg_struct(&mystruct), side_arg_u8(55)));
 116         }
 117 }
 118
 119 side_static_event(my_provider_event_array, "myprovider", "myarray", SIDE_LOGLEVEL_DEBUG,
 120         side_field_list(
 121                 side_field_array("arr", side_elem(side_type_u32(side_attr_list())), 3, side_attr_list()),
 122                 side_field_s64("v", side_attr_list()),
 123         ),
 124         side_attr_list()
 125 );
 126
 127 static
 128 void test_array(void)
 129 {
 130         side_event_enable__my_provider_event_array = 1;
 131         side_event_cond(my_provider_event_array) {
 132                 side_arg_define_vec(myarray, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
 133                 side_event_call(my_provider_event_array, side_arg_list(side_arg_array(&myarray), side_arg_s64(42)));
 134         }
 135 }
 136
 137 side_static_event(my_provider_event_vla, "myprovider", "myvla", SIDE_LOGLEVEL_DEBUG,
 138         side_field_list(
 139                 side_field_vla("vla", side_elem(side_type_u32(side_attr_list())), side_attr_list()),
 140                 side_field_s64("v", side_attr_list()),
 141         ),
 142         side_attr_list()
 143 );
 144
 145 static
 146 void test_vla(void)
 147 {
 148         side_event_enable__my_provider_event_vla = 1;
 149         side_event_cond(my_provider_event_vla) {
 150                 side_arg_define_vec(myvla, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
 151                 side_event_call(my_provider_event_vla, side_arg_list(side_arg_vla(&myvla), side_arg_s64(42)));
 152         }
 153 }
 154
 155 /* 1D array visitor */
 156
 157 struct app_visitor_ctx {
 158         const uint32_t *ptr;
 159         uint32_t length;
 160 };
 161
 162 static
 163 enum side_visitor_status test_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 164 {
 165         struct app_visitor_ctx *ctx = (struct app_visitor_ctx *) _ctx;
 166         uint32_t length = ctx->length, i;
 167
 168         for (i = 0; i < length; i++) {
 169                 const struct side_arg_vec elem = side_arg_u32(ctx->ptr[i]);
 170
 171                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 172                         return SIDE_VISITOR_STATUS_ERROR;
 173         }
 174         return SIDE_VISITOR_STATUS_OK;
 175 }
 176
 177 static uint32_t testarray[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 178
 179 side_static_event(my_provider_event_vla_visitor, "myprovider", "myvlavisit", SIDE_LOGLEVEL_DEBUG,
 180         side_field_list(
 181                 side_field_vla_visitor("vlavisit", side_elem(side_type_u32(side_attr_list())), test_visitor, side_attr_list()),
 182                 side_field_s64("v", side_attr_list()),
 183         ),
 184         side_attr_list()
 185 );
 186
 187 static
 188 void test_vla_visitor(void)
 189 {
 190         side_event_enable__my_provider_event_vla_visitor = 1;
 191         side_event_cond(my_provider_event_vla_visitor) {
 192                 struct app_visitor_ctx ctx = {
 193                         .ptr = testarray,
 194                         .length = SIDE_ARRAY_SIZE(testarray),
 195                 };
 196                 side_event_call(my_provider_event_vla_visitor, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
 197         }
 198 }
 199
 200 /* 2D array visitor */
 201
 202 struct app_visitor_2d_inner_ctx {
 203         const uint32_t *ptr;
 204         uint32_t length;
 205 };
 206
 207 static
 208 enum side_visitor_status test_inner_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 209 {
 210         struct app_visitor_2d_inner_ctx *ctx = (struct app_visitor_2d_inner_ctx *) _ctx;
 211         uint32_t length = ctx->length, i;
 212
 213         for (i = 0; i < length; i++) {
 214                 const struct side_arg_vec elem = side_arg_u32(ctx->ptr[i]);
 215
 216                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 217                         return SIDE_VISITOR_STATUS_ERROR;
 218         }
 219         return SIDE_VISITOR_STATUS_OK;
 220 }
 221
 222 struct app_visitor_2d_outer_ctx {
 223         const uint32_t (*ptr)[2];
 224         uint32_t length;
 225 };
 226
 227 static
 228 enum side_visitor_status test_outer_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 229 {
 230         struct app_visitor_2d_outer_ctx *ctx = (struct app_visitor_2d_outer_ctx *) _ctx;
 231         uint32_t length = ctx->length, i;
 232
 233         for (i = 0; i < length; i++) {
 234                 struct app_visitor_2d_inner_ctx inner_ctx = {
 235                         .ptr = ctx->ptr[i],
 236                         .length = 2,
 237                 };
 238                 const struct side_arg_vec elem = side_arg_vla_visitor(&inner_ctx);
 239                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 240                         return SIDE_VISITOR_STATUS_ERROR;
 241         }
 242         return SIDE_VISITOR_STATUS_OK;
 243 }
 244
 245 static uint32_t testarray2d[][2] = {
 246         { 1, 2 },
 247         { 33, 44 },
 248         { 55, 66 },
 249 };
 250
 251 side_static_event(my_provider_event_vla_visitor2d, "myprovider", "myvlavisit2d", SIDE_LOGLEVEL_DEBUG,
 252         side_field_list(
 253                 side_field_vla_visitor("vlavisit2d",
 254                         side_elem(
 255                                 side_type_vla_visitor(
 256                                         side_elem(side_type_u32(side_attr_list())),
 257                                         test_inner_visitor,
 258                                         side_attr_list())
 259                         ), test_outer_visitor, side_attr_list()),
 260                 side_field_s64("v", side_attr_list()),
 261         ),
 262         side_attr_list()
 263 );
 264
 265 static
 266 void test_vla_visitor_2d(void)
 267 {
 268         side_event_enable__my_provider_event_vla_visitor2d = 1;
 269         side_event_cond(my_provider_event_vla_visitor2d) {
 270                 struct app_visitor_2d_outer_ctx ctx = {
 271                         .ptr = testarray2d,
 272                         .length = SIDE_ARRAY_SIZE(testarray2d),
 273                 };
 274                 side_event_call(my_provider_event_vla_visitor2d, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
 275         }
 276 }
 277
 278 static int64_t array_fixint[] = { -444, 555, 123, 2897432587 };
 279
 280 side_static_event(my_provider_event_array_fixint, "myprovider", "myarrayfixint", SIDE_LOGLEVEL_DEBUG,
 281         side_field_list(
 282                 side_field_array("arrfixint", side_elem(side_type_s64(side_attr_list())), SIDE_ARRAY_SIZE(array_fixint), side_attr_list()),
 283                 side_field_s64("v", side_attr_list()),
 284         ),
 285         side_attr_list()
 286 );
 287
 288 static
 289 void test_array_fixint(void)
 290 {
 291         side_event_enable__my_provider_event_array_fixint = 1;
 292         side_event(my_provider_event_array_fixint,
 293                 side_arg_list(side_arg_array_s64(array_fixint), side_arg_s64(42)));
 294 }
 295
 296 static int64_t vla_fixint[] = { -444, 555, 123, 2897432587 };
 297
 298 side_static_event(my_provider_event_vla_fixint, "myprovider", "myvlafixint", SIDE_LOGLEVEL_DEBUG,
 299         side_field_list(
 300                 side_field_vla("vlafixint", side_elem(side_type_s64(side_attr_list())), side_attr_list()),
 301                 side_field_s64("v", side_attr_list()),
 302         ),
 303         side_attr_list()
 304 );
 305
 306 static
 307 void test_vla_fixint(void)
 308 {
 309         side_event_enable__my_provider_event_vla_fixint = 1;
 310         side_event(my_provider_event_vla_fixint,
 311                 side_arg_list(side_arg_vla_s64(vla_fixint, SIDE_ARRAY_SIZE(vla_fixint)), side_arg_s64(42)));
 312 }
 313
 314 side_static_event(my_provider_event_dynamic_basic,
 315         "myprovider", "mydynamicbasic", SIDE_LOGLEVEL_DEBUG,
 316         side_field_list(
 317                 side_field_dynamic("dynamic", side_attr_list()),
 318         ),
 319         side_attr_list()
 320 );
 321
 322 static
 323 void test_dynamic_basic_type(void)
 324 {
 325         side_event_enable__my_provider_event_dynamic_basic = 1;
 326         side_event(my_provider_event_dynamic_basic,
 327                 side_arg_list(side_arg_dynamic(side_arg_dynamic_s16(-33, side_attr_list()))));
 328 }
 329
 330 side_static_event(my_provider_event_dynamic_vla,
 331         "myprovider", "mydynamicvla", SIDE_LOGLEVEL_DEBUG,
 332         side_field_list(
 333                 side_field_dynamic("dynamic", side_attr_list()),
 334         ),
 335         side_attr_list()
 336 );
 337
 338 static
 339 void test_dynamic_vla(void)
 340 {
 341         side_arg_dynamic_define_vec(myvla,
 342                 side_arg_list(
 343                         side_arg_dynamic_u32(1, side_attr_list()),
 344                         side_arg_dynamic_u32(2, side_attr_list()),
 345                         side_arg_dynamic_u32(3, side_attr_list()),
 346                 ),
 347                 side_attr_list()
 348         );
 349         side_event_enable__my_provider_event_dynamic_vla = 1;
 350         side_event(my_provider_event_dynamic_vla,
 351                 side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
 352 }
 353
 354 side_static_event(my_provider_event_dynamic_null,
 355         "myprovider", "mydynamicnull", SIDE_LOGLEVEL_DEBUG,
 356         side_field_list(
 357                 side_field_dynamic("dynamic", side_attr_list()),
 358         ),
 359         side_attr_list()
 360 );
 361
 362 static
 363 void test_dynamic_null(void)
 364 {
 365         side_event_enable__my_provider_event_dynamic_null = 1;
 366         side_event(my_provider_event_dynamic_null,
 367                 side_arg_list(side_arg_dynamic(side_arg_dynamic_null(side_attr_list()))));
 368 }
 369
 370 side_static_event(my_provider_event_dynamic_struct,
 371         "myprovider", "mydynamicstruct", SIDE_LOGLEVEL_DEBUG,
 372         side_field_list(
 373                 side_field_dynamic("dynamic", side_attr_list()),
 374         ),
 375         side_attr_list()
 376 );
 377
 378 static
 379 void test_dynamic_struct(void)
 380 {
 381         side_arg_dynamic_define_struct(mystruct,
 382                 side_arg_list(
 383                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
 384                         side_arg_dynamic_field("b", side_arg_dynamic_string("zzz", side_attr_list())),
 385                         side_arg_dynamic_field("c", side_arg_dynamic_null(side_attr_list())),
 386                 ),
 387                 side_attr_list()
 388         );
 389
 390         side_event_enable__my_provider_event_dynamic_struct = 1;
 391         side_event(my_provider_event_dynamic_struct,
 392                 side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
 393 }
 394
 395 side_static_event(my_provider_event_dynamic_nested_struct,
 396         "myprovider", "mydynamicnestedstruct", SIDE_LOGLEVEL_DEBUG,
 397         side_field_list(
 398                 side_field_dynamic("dynamic", side_attr_list()),
 399         ),
 400         side_attr_list()
 401 );
 402
 403 static
 404 void test_dynamic_nested_struct(void)
 405 {
 406         side_arg_dynamic_define_struct(nested,
 407                 side_arg_list(
 408                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
 409                         side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
 410                 ),
 411                 side_attr_list()
 412         );
 413         side_arg_dynamic_define_struct(nested2,
 414                 side_arg_list(
 415                         side_arg_dynamic_field("aa", side_arg_dynamic_u64(128, side_attr_list())),
 416                         side_arg_dynamic_field("bb", side_arg_dynamic_u16(1, side_attr_list())),
 417                 ),
 418                 side_attr_list()
 419         );
 420         side_arg_dynamic_define_struct(mystruct,
 421                 side_arg_list(
 422                         side_arg_dynamic_field("nested", side_arg_dynamic_struct(&nested)),
 423                         side_arg_dynamic_field("nested2", side_arg_dynamic_struct(&nested2)),
 424                 ),
 425                 side_attr_list()
 426         );
 427         side_event_enable__my_provider_event_dynamic_nested_struct = 1;
 428         side_event(my_provider_event_dynamic_nested_struct,
 429                 side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
 430 }
 431
 432 side_static_event(my_provider_event_dynamic_vla_struct,
 433         "myprovider", "mydynamicvlastruct", SIDE_LOGLEVEL_DEBUG,
 434         side_field_list(
 435                 side_field_dynamic("dynamic", side_attr_list()),
 436         ),
 437         side_attr_list()
 438 );
 439
 440 static
 441 void test_dynamic_vla_struct(void)
 442 {
 443         side_arg_dynamic_define_struct(nested,
 444                 side_arg_list(
 445                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
 446                         side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
 447                 ),
 448                 side_attr_list()
 449         );
 450         side_arg_dynamic_define_vec(myvla,
 451                 side_arg_list(
 452                         side_arg_dynamic_struct(&nested),
 453                         side_arg_dynamic_struct(&nested),
 454                         side_arg_dynamic_struct(&nested),
 455                         side_arg_dynamic_struct(&nested),
 456                 ),
 457                 side_attr_list()
 458         );
 459         side_event_enable__my_provider_event_dynamic_vla_struct = 1;
 460         side_event(my_provider_event_dynamic_vla_struct,
 461                 side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
 462 }
 463
 464 side_static_event(my_provider_event_dynamic_struct_vla,
 465         "myprovider", "mydynamicstructvla", SIDE_LOGLEVEL_DEBUG,
 466         side_field_list(
 467                 side_field_dynamic("dynamic", side_attr_list()),
 468         ),
 469         side_attr_list()
 470 );
 471
 472 static
 473 void test_dynamic_struct_vla(void)
 474 {
 475         side_arg_dynamic_define_vec(myvla,
 476                 side_arg_list(
 477                         side_arg_dynamic_u32(1, side_attr_list()),
 478                         side_arg_dynamic_u32(2, side_attr_list()),
 479                         side_arg_dynamic_u32(3, side_attr_list()),
 480                 ),
 481                 side_attr_list()
 482         );
 483         side_arg_dynamic_define_vec(myvla2,
 484                 side_arg_list(
 485                         side_arg_dynamic_u32(4, side_attr_list()),
 486                         side_arg_dynamic_u64(5, side_attr_list()),
 487                         side_arg_dynamic_u32(6, side_attr_list()),
 488                 ),
 489                 side_attr_list()
 490         );
 491         side_arg_dynamic_define_struct(mystruct,
 492                 side_arg_list(
 493                         side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla)),
 494                         side_arg_dynamic_field("b", side_arg_dynamic_vla(&myvla2)),
 495                 ),
 496                 side_attr_list()
 497         );
 498         side_event_enable__my_provider_event_dynamic_struct_vla = 1;
 499         side_event(my_provider_event_dynamic_struct_vla,
 500                 side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
 501 }
 502
 503 side_static_event(my_provider_event_dynamic_nested_vla,
 504         "myprovider", "mydynamicnestedvla", SIDE_LOGLEVEL_DEBUG,
 505         side_field_list(
 506                 side_field_dynamic("dynamic", side_attr_list()),
 507         ),
 508         side_attr_list()
 509 );
 510
 511 static
 512 void test_dynamic_nested_vla(void)
 513 {
 514         side_arg_dynamic_define_vec(nestedvla,
 515                 side_arg_list(
 516                         side_arg_dynamic_u32(1, side_attr_list()),
 517                         side_arg_dynamic_u16(2, side_attr_list()),
 518                         side_arg_dynamic_u32(3, side_attr_list()),
 519                 ),
 520                 side_attr_list()
 521         );
 522         side_arg_dynamic_define_vec(nestedvla2,
 523                 side_arg_list(
 524                         side_arg_dynamic_u8(4, side_attr_list()),
 525                         side_arg_dynamic_u32(5, side_attr_list()),
 526                         side_arg_dynamic_u32(6, side_attr_list()),
 527                 ),
 528                 side_attr_list()
 529         );
 530         side_arg_dynamic_define_vec(myvla,
 531                 side_arg_list(
 532                         side_arg_dynamic_vla(&nestedvla),
 533                         side_arg_dynamic_vla(&nestedvla2),
 534                 ),
 535                 side_attr_list()
 536         );
 537         side_event_enable__my_provider_event_dynamic_nested_vla = 1;
 538         side_event(my_provider_event_dynamic_nested_vla,
 539                 side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
 540 }
 541
 542 side_static_event_variadic(my_provider_event_variadic,
 543         "myprovider", "myvariadicevent", SIDE_LOGLEVEL_DEBUG,
 544         side_field_list(),
 545         side_attr_list()
 546 );
 547
 548 static
 549 void test_variadic(void)
 550 {
 551         side_event_enable__my_provider_event_variadic = 1;
 552         side_event_variadic(my_provider_event_variadic,
 553                 side_arg_list(),
 554                 side_arg_list(
 555                         side_arg_dynamic_field("a", side_arg_dynamic_u32(55, side_attr_list())),
 556                         side_arg_dynamic_field("b", side_arg_dynamic_s8(-4, side_attr_list())),
 557                 ),
 558                 side_attr_list()
 559         );
 560 }
 561
 562 side_static_event_variadic(my_provider_event_static_variadic,
 563         "myprovider", "mystaticvariadicevent", SIDE_LOGLEVEL_DEBUG,
 564         side_field_list(
 565                 side_field_u32("abc", side_attr_list()),
 566                 side_field_u16("def", side_attr_list()),
 567         ),
 568         side_attr_list()
 569 );
 570
 571 static
 572 void test_static_variadic(void)
 573 {
 574         side_event_enable__my_provider_event_static_variadic = 1;
 575         side_event_variadic(my_provider_event_static_variadic,
 576                 side_arg_list(
 577                         side_arg_u32(1),
 578                         side_arg_u16(2),
 579                 ),
 580                 side_arg_list(
 581                         side_arg_dynamic_field("a", side_arg_dynamic_u32(55, side_attr_list())),
 582                         side_arg_dynamic_field("b", side_arg_dynamic_s8(-4, side_attr_list())),
 583                 ),
 584                 side_attr_list()
 585         );
 586 }
 587
 588 side_static_event(my_provider_event_bool, "myprovider", "myeventbool", SIDE_LOGLEVEL_DEBUG,
 589         side_field_list(
 590                 side_field_bool("a_false", side_attr_list()),
 591                 side_field_bool("b_true", side_attr_list()),
 592                 side_field_bool("c_true", side_attr_list()),
 593                 side_field_bool("d_true", side_attr_list()),
 594                 side_field_bool("e_true", side_attr_list()),
 595                 side_field_bool("f_false", side_attr_list()),
 596                 side_field_bool("g_true", side_attr_list()),
 597         ),
 598         side_attr_list()
 599 );
 600
 601 static
 602 void test_bool(void)
 603 {
 604         uint32_t a = 0;
 605         uint32_t b = 1;
 606         uint64_t c = 0x12345678;
 607         int16_t d = -32768;
 608         bool e = true;
 609         bool f = false;
 610         uint32_t g = 256;
 611
 612         side_event_enable__my_provider_event_bool = 1;
 613         side_event(my_provider_event_bool,
 614                 side_arg_list(
 615                         side_arg_bool(a),
 616                         side_arg_bool(b),
 617                         side_arg_bool(c),
 618                         side_arg_bool(d),
 619                         side_arg_bool(e),
 620                         side_arg_bool(f),
 621                         side_arg_bool(g),
 622                 )
 623         );
 624 }
 625
 626 side_static_event_variadic(my_provider_event_dynamic_bool,
 627         "myprovider", "mydynamicbool", SIDE_LOGLEVEL_DEBUG,
 628         side_field_list(),
 629         side_attr_list()
 630 );
 631
 632 static
 633 void test_dynamic_bool(void)
 634 {
 635         side_event_enable__my_provider_event_dynamic_bool = 1;
 636         side_event_variadic(my_provider_event_dynamic_bool,
 637                 side_arg_list(),
 638                 side_arg_list(
 639                         side_arg_dynamic_field("a_true", side_arg_dynamic_bool(55, side_attr_list())),
 640                         side_arg_dynamic_field("b_true", side_arg_dynamic_bool(-4, side_attr_list())),
 641                         side_arg_dynamic_field("c_false", side_arg_dynamic_bool(0, side_attr_list())),
 642                         side_arg_dynamic_field("d_true", side_arg_dynamic_bool(256, side_attr_list())),
 643                 ),
 644                 side_attr_list()
 645         );
 646 }
 647
 648 side_static_event(my_provider_event_dynamic_vla_visitor,
 649         "myprovider", "mydynamicvlavisitor", SIDE_LOGLEVEL_DEBUG,
 650         side_field_list(
 651                 side_field_dynamic("dynamic", side_attr_list()),
 652         ),
 653         side_attr_list()
 654 );
 655
 656 struct app_dynamic_vla_visitor_ctx {
 657         const uint32_t *ptr;
 658         uint32_t length;
 659 };
 660
 661 static
 662 enum side_visitor_status test_dynamic_vla_visitor(const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx, void *_ctx)
 663 {
 664         struct app_dynamic_vla_visitor_ctx *ctx = (struct app_dynamic_vla_visitor_ctx *) _ctx;
 665         uint32_t length = ctx->length, i;
 666
 667         for (i = 0; i < length; i++) {
 668                 const struct side_arg_dynamic_vec elem = {
 669                         .dynamic_type = SIDE_DYNAMIC_TYPE_U32,
 670                         .u = {
 671                                 .side_basic = {
 672                                         .attr = NULL,
 673                                         .nr_attr = 0,
 674                                         .u = {
 675                                                 .side_u32 = ctx->ptr[i],
 676                                         },
 677                                 },
 678                         },
 679                 };
 680                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 681                         return SIDE_VISITOR_STATUS_ERROR;
 682         }
 683         return SIDE_VISITOR_STATUS_OK;
 684 }
 685
 686 static uint32_t testarray_dynamic_vla[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 687
 688 static
 689 void test_dynamic_vla_with_visitor(void)
 690 {
 691         side_event_enable__my_provider_event_dynamic_vla_visitor = 1;
 692         side_event_cond(my_provider_event_dynamic_vla_visitor) {
 693                 struct app_dynamic_vla_visitor_ctx ctx = {
 694                         .ptr = testarray_dynamic_vla,
 695                         .length = SIDE_ARRAY_SIZE(testarray_dynamic_vla),
 696                 };
 697                 side_event_call(my_provider_event_dynamic_vla_visitor,
 698                         side_arg_list(
 699                                 side_arg_dynamic(
 700                                         side_arg_dynamic_vla_visitor(test_dynamic_vla_visitor, &ctx, side_attr_list())
 701                                 )
 702                         )
 703                 );
 704         }
 705 }
 706
 707 side_static_event(my_provider_event_dynamic_struct_visitor,
 708         "myprovider", "mydynamicstructvisitor", SIDE_LOGLEVEL_DEBUG,
 709         side_field_list(
 710                 side_field_dynamic("dynamic", side_attr_list()),
 711         ),
 712         side_attr_list()
 713 );
 714
 715 struct struct_visitor_pair {
 716         const char *name;
 717         uint32_t value;
 718 };
 719
 720 struct app_dynamic_struct_visitor_ctx {
 721         const struct struct_visitor_pair *ptr;
 722         uint32_t length;
 723 };
 724
 725 static
 726 enum side_visitor_status test_dynamic_struct_visitor(const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx, void *_ctx)
 727 {
 728         struct app_dynamic_struct_visitor_ctx *ctx = (struct app_dynamic_struct_visitor_ctx *) _ctx;
 729         uint32_t length = ctx->length, i;
 730
 731         for (i = 0; i < length; i++) {
 732                 struct side_arg_dynamic_event_field dynamic_field = {
 733                         .field_name = ctx->ptr[i].name,
 734                         .elem = {
 735                                 .dynamic_type = SIDE_DYNAMIC_TYPE_U32,
 736                                 .u = {
 737                                         .side_basic = {
 738                                                 .nr_attr = 0,
 739                                                 .attr = NULL,
 740                                                 .u = {
 741                                                         .side_u32 = ctx->ptr[i].value,
 742                                                 },
 743                                         },
 744                                 },
 745                         },
 746                 };
 747                 if (tracer_ctx->write_field(tracer_ctx, &dynamic_field) != SIDE_VISITOR_STATUS_OK)
 748                         return SIDE_VISITOR_STATUS_ERROR;
 749         }
 750         return SIDE_VISITOR_STATUS_OK;
 751 }
 752
 753 static struct struct_visitor_pair testarray_dynamic_struct[] = {
 754         { "a", 1, },
 755         { "b", 2, },
 756         { "c", 3, },
 757         { "d", 4, },
 758 };
 759
 760 static
 761 void test_dynamic_struct_with_visitor(void)
 762 {
 763         side_event_enable__my_provider_event_dynamic_struct_visitor = 1;
 764         side_event_cond(my_provider_event_dynamic_struct_visitor) {
 765                 struct app_dynamic_struct_visitor_ctx ctx = {
 766                         .ptr = testarray_dynamic_struct,
 767                         .length = SIDE_ARRAY_SIZE(testarray_dynamic_struct),
 768                 };
 769                 side_event_call(my_provider_event_dynamic_struct_visitor,
 770                         side_arg_list(
 771                                 side_arg_dynamic(
 772                                         side_arg_dynamic_struct_visitor(test_dynamic_struct_visitor, &ctx, side_attr_list())
 773                                 )
 774                         )
 775                 );
 776         }
 777 }
 778
 779 side_static_event(my_provider_event_user_attribute, "myprovider", "myevent_user_attribute", SIDE_LOGLEVEL_DEBUG,
 780         side_field_list(
 781                 side_field_u32("abc", side_attr_list()),
 782                 side_field_s64("def", side_attr_list()),
 783         ),
 784         side_attr_list(
 785                 side_attr("user_attribute_a", side_attr_string("val1")),
 786                 side_attr("user_attribute_b", side_attr_string("val2")),
 787         )
 788 );
 789
 790 static
 791 void test_event_user_attribute(void)
 792 {
 793         side_event_enable__my_provider_event_user_attribute = 1;
 794         side_event(my_provider_event_user_attribute, side_arg_list(side_arg_u32(1), side_arg_s64(2)));
 795 }
 796
 797 side_static_event(my_provider_field_user_attribute, "myprovider", "myevent_field_attribute", SIDE_LOGLEVEL_DEBUG,
 798         side_field_list(
 799                 side_field_u32("abc",
 800                         side_attr_list(
 801                                 side_attr("user_attribute_a", side_attr_string("val1")),
 802                                 side_attr("user_attribute_b", side_attr_u32(2)),
 803                         )
 804                 ),
 805                 side_field_s64("def",
 806                         side_attr_list(
 807                                 side_attr("user_attribute_c", side_attr_string("val3")),
 808                                 side_attr("user_attribute_d", side_attr_s64(-5)),
 809                         )
 810                 ),
 811         ),
 812         side_attr_list()
 813 );
 814
 815 static
 816 void test_field_user_attribute(void)
 817 {
 818         side_event_enable__my_provider_field_user_attribute = 1;
 819         side_event(my_provider_field_user_attribute, side_arg_list(side_arg_u32(1), side_arg_s64(2)));
 820 }
 821
 822 side_static_event_variadic(my_provider_event_variadic_attr,
 823         "myprovider", "myvariadiceventattr", SIDE_LOGLEVEL_DEBUG,
 824         side_field_list(),
 825         side_attr_list()
 826 );
 827
 828 static
 829 void test_variadic_attr(void)
 830 {
 831         side_event_enable__my_provider_event_variadic_attr = 1;
 832         side_event_variadic(my_provider_event_variadic_attr,
 833                 side_arg_list(),
 834                 side_arg_list(
 835                         side_arg_dynamic_field("a",
 836                                 side_arg_dynamic_u32(55,
 837                                         side_attr_list(
 838                                                 side_attr("user_attribute_c", side_attr_string("valX")),
 839                                                 side_attr("user_attribute_d", side_attr_u8(55)),
 840                                         )
 841                                 )
 842                         ),
 843                         side_arg_dynamic_field("b",
 844                                 side_arg_dynamic_s8(-4,
 845                                         side_attr_list(
 846                                                 side_attr("X", side_attr_u8(1)),
 847                                                 side_attr("Y", side_attr_s8(2)),
 848                                         )
 849                                 )
 850                         ),
 851                 ),
 852                 side_attr_list()
 853         );
 854 }
 855
 856 side_static_event_variadic(my_provider_event_variadic_vla_attr,
 857         "myprovider", "myvariadiceventvlaattr", SIDE_LOGLEVEL_DEBUG,
 858         side_field_list(),
 859         side_attr_list()
 860 );
 861
 862 static
 863 void test_variadic_vla_attr(void)
 864 {
 865         side_arg_dynamic_define_vec(myvla,
 866                 side_arg_list(
 867                         side_arg_dynamic_u32(1,
 868                                 side_attr_list(
 869                                         side_attr("Z", side_attr_u8(0)),
 870                                         side_attr("A", side_attr_u8(123)),
 871                                 )
 872                         ),
 873                         side_arg_dynamic_u32(2, side_attr_list()),
 874                         side_arg_dynamic_u32(3, side_attr_list()),
 875                 ),
 876                 side_attr_list(
 877                         side_attr("X", side_attr_u8(1)),
 878                         side_attr("Y", side_attr_u8(2)),
 879                 )
 880         );
 881         side_event_enable__my_provider_event_variadic_vla_attr = 1;
 882         side_event_variadic(my_provider_event_variadic_vla_attr,
 883                 side_arg_list(),
 884                 side_arg_list(
 885                         side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla)),
 886                 ),
 887                 side_attr_list()
 888         );
 889 }
 890
 891 side_static_event_variadic(my_provider_event_variadic_struct_attr,
 892         "myprovider", "myvariadiceventstructattr", SIDE_LOGLEVEL_DEBUG,
 893         side_field_list(),
 894         side_attr_list()
 895 );
 896
 897 static
 898 void test_variadic_struct_attr(void)
 899 {
 900         side_event_enable__my_provider_event_variadic_struct_attr = 1;
 901         side_event_cond(my_provider_event_variadic_struct_attr) {
 902                 side_arg_dynamic_define_struct(mystruct,
 903                         side_arg_list(
 904                                 side_arg_dynamic_field("a",
 905                                         side_arg_dynamic_u32(43,
 906                                                 side_attr_list(
 907                                                         side_attr("A", side_attr_bool(true)),
 908                                                 )
 909                                         )
 910                                 ),
 911                                 side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
 912                         ),
 913                         side_attr_list(
 914                                 side_attr("X", side_attr_u8(1)),
 915                                 side_attr("Y", side_attr_u8(2)),
 916                         )
 917                 );
 918                 side_event_call_variadic(my_provider_event_variadic_struct_attr,
 919                         side_arg_list(),
 920                         side_arg_list(
 921                                 side_arg_dynamic_field("a", side_arg_dynamic_struct(&mystruct)),
 922                         ),
 923                         side_attr_list()
 924                 );
 925         }
 926 }
 927
 928 side_static_event(my_provider_event_float, "myprovider", "myeventfloat", SIDE_LOGLEVEL_DEBUG,
 929         side_field_list(
 930 #if __HAVE_FLOAT16
 931                 side_field_float_binary16("binary16", side_attr_list()),
 932 #endif
 933 #if __HAVE_FLOAT32
 934                 side_field_float_binary32("binary32", side_attr_list()),
 935 #endif
 936 #if __HAVE_FLOAT64
 937                 side_field_float_binary64("binary64", side_attr_list()),
 938 #endif
 939 #if __HAVE_FLOAT128
 940                 side_field_float_binary128("binary128", side_attr_list()),
 941 #endif
 942         ),
 943         side_attr_list()
 944 );
 945
 946 static
 947 void test_float(void)
 948 {
 949         side_event_enable__my_provider_event_float = 1;
 950         side_event(my_provider_event_float,
 951                 side_arg_list(
 952 #if __HAVE_FLOAT16
 953                         side_arg_float_binary16(1.1),
 954 #endif
 955 #if __HAVE_FLOAT32
 956                         side_arg_float_binary32(2.2),
 957 #endif
 958 #if __HAVE_FLOAT64
 959                         side_arg_float_binary64(3.3),
 960 #endif
 961 #if __HAVE_FLOAT128
 962                         side_arg_float_binary128(4.4),
 963 #endif
 964                 )
 965         );
 966 }
 967
 968 side_static_event_variadic(my_provider_event_variadic_float,
 969         "myprovider", "myvariadicfloat", SIDE_LOGLEVEL_DEBUG,
 970         side_field_list(),
 971         side_attr_list()
 972 );
 973
 974 static
 975 void test_variadic_float(void)
 976 {
 977         side_event_enable__my_provider_event_variadic_float = 1;
 978         side_event_variadic(my_provider_event_variadic_float,
 979                 side_arg_list(),
 980                 side_arg_list(
 981 #if __HAVE_FLOAT16
 982                         side_arg_dynamic_field("binary16",
 983                                 side_arg_dynamic_float_binary16(1.1, side_attr_list())
 984                         ),
 985 #endif
 986 #if __HAVE_FLOAT32
 987                         side_arg_dynamic_field("binary32",
 988                                 side_arg_dynamic_float_binary32(2.2, side_attr_list())
 989                         ),
 990 #endif
 991 #if __HAVE_FLOAT64
 992                         side_arg_dynamic_field("binary64",
 993                                 side_arg_dynamic_float_binary64(3.3, side_attr_list())
 994                         ),
 995 #endif
 996 #if __HAVE_FLOAT128
 997                         side_arg_dynamic_field("binary128",
 998                                 side_arg_dynamic_float_binary128(4.4, side_attr_list())
 999                         ),
1000 #endif
1001                 ),
1002                 side_attr_list()
1003         );
1004 }
1005
1006 static side_define_enum(myenum,
1007         side_enum_mapping_list(
1008                 side_enum_mapping_range("one-ten", 1, 10),
1009                 side_enum_mapping_range("100-200", 100, 200),
1010                 side_enum_mapping_value("200", 200),
1011                 side_enum_mapping_value("300", 300),
1012         ),
1013         side_attr_list()
1014 );
1015
1016 side_static_event(my_provider_event_enum, "myprovider", "myeventenum", SIDE_LOGLEVEL_DEBUG,
1017         side_field_list(
1018                 side_field_enum("5", &myenum, side_elem(side_type_u32(side_attr_list()))),
1019                 side_field_enum("400", &myenum, side_elem(side_type_u64(side_attr_list()))),
1020                 side_field_enum("200", &myenum, side_elem(side_type_u8(side_attr_list()))),
1021                 side_field_enum("-100", &myenum, side_elem(side_type_s8(side_attr_list()))),
1022         ),
1023         side_attr_list()
1024 );
1025
1026 static
1027 void test_enum(void)
1028 {
1029         side_event_enable__my_provider_event_enum = 1;
1030         side_event(my_provider_event_enum,
1031                 side_arg_list(
1032                         side_arg_u32(5),
1033                         side_arg_u64(400),
1034                         side_arg_u8(200),
1035                         side_arg_s8(-100),
1036                 )
1037         );
1038 }
1039
1040 /* A bitmap enum maps bits to labels. */
1041 static side_define_enum_bitmap(myenum_bitmap,
1042         side_enum_bitmap_mapping_list(
1043                 side_enum_bitmap_mapping_value("0", 0),
1044                 side_enum_bitmap_mapping_range("1-2", 1, 2),
1045                 side_enum_bitmap_mapping_range("2-4", 2, 4),
1046                 side_enum_bitmap_mapping_value("3", 3),
1047                 side_enum_bitmap_mapping_value("30", 30),
1048                 side_enum_bitmap_mapping_value("63", 63),
1049                 side_enum_bitmap_mapping_range("158-160", 158, 160),
1050                 side_enum_bitmap_mapping_value("159", 159),
1051                 side_enum_bitmap_mapping_range("500-700", 500, 700),
1052         ),
1053         side_attr_list()
1054 );
1055
1056 side_static_event(my_provider_event_enum_bitmap, "myprovider", "myeventenumbitmap", SIDE_LOGLEVEL_DEBUG,
1057         side_field_list(
1058                 side_field_enum_bitmap("bit_0", &myenum_bitmap, side_elem(side_type_u32(side_attr_list()))),
1059                 side_field_enum_bitmap("bit_1", &myenum_bitmap, side_elem(side_type_u32(side_attr_list()))),
1060                 side_field_enum_bitmap("bit_2", &myenum_bitmap, side_elem(side_type_u8(side_attr_list()))),
1061                 side_field_enum_bitmap("bit_3", &myenum_bitmap, side_elem(side_type_u8(side_attr_list()))),
1062                 side_field_enum_bitmap("bit_30", &myenum_bitmap, side_elem(side_type_u32(side_attr_list()))),
1063                 side_field_enum_bitmap("bit_31", &myenum_bitmap, side_elem(side_type_u32(side_attr_list()))),
1064                 side_field_enum_bitmap("bit_63", &myenum_bitmap, side_elem(side_type_u64(side_attr_list()))),
1065                 side_field_enum_bitmap("bits_1+63", &myenum_bitmap, side_elem(side_type_u64(side_attr_list()))),
1066                 side_field_enum_bitmap("byte_bit_2", &myenum_bitmap, side_elem(side_type_byte(side_attr_list()))),
1067                 side_field_enum_bitmap("bit_159", &myenum_bitmap,
1068                         side_elem(side_type_array(side_elem(side_type_u32(side_attr_list())), 5, side_attr_list()))),
1069                 side_field_enum_bitmap("bit_159", &myenum_bitmap,
1070                         side_elem(side_type_vla(side_elem(side_type_u32(side_attr_list())), side_attr_list()))),
1071         ),
1072         side_attr_list()
1073 );
1074
1075 static
1076 void test_enum_bitmap(void)
1077 {
1078         side_event_enable__my_provider_event_enum_bitmap = 1;
1079         side_event_cond(my_provider_event_enum_bitmap) {
1080                 side_arg_define_vec(myarray,
1081                         side_arg_list(
1082                                 side_arg_u32(0),
1083                                 side_arg_u32(0),
1084                                 side_arg_u32(0),
1085                                 side_arg_u32(0),
1086                                 side_arg_u32(0x80000000),       /* bit 159 */
1087                         )
1088                 );
1089                 side_event_call(my_provider_event_enum_bitmap,
1090                         side_arg_list(
1091                                 side_arg_u32(1 << 0),
1092                                 side_arg_u32(1 << 1),
1093                                 side_arg_u8(1 << 2),
1094                                 side_arg_u8(1 << 3),
1095                                 side_arg_u32(1 << 30),
1096                                 side_arg_u32(1 << 31),
1097                                 side_arg_u64(1ULL << 63),
1098                                 side_arg_u64((1ULL << 1) | (1ULL << 63)),
1099                                 side_arg_byte(1 << 2),
1100                                 side_arg_array(&myarray),
1101                                 side_arg_vla(&myarray),
1102                         )
1103                 );
1104         }
1105 }
1106
1107 static uint8_t blob_fixint[] = { 0x55, 0x44, 0x33, 0x22, 0x11 };
1108
1109 side_static_event_variadic(my_provider_event_blob, "myprovider", "myeventblob", SIDE_LOGLEVEL_DEBUG,
1110         side_field_list(
1111                 side_field_byte("blobfield", side_attr_list()),
1112                 side_field_array("arrayblob", side_elem(side_type_byte(side_attr_list())), 3, side_attr_list()),
1113                 side_field_array("arrayblobfix", side_elem(side_type_byte(side_attr_list())), SIDE_ARRAY_SIZE(blob_fixint), side_attr_list()),
1114                 side_field_vla("vlablobfix", side_elem(side_type_byte(side_attr_list())), side_attr_list()),
1115         ),
1116         side_attr_list()
1117 );
1118
1119 static
1120 void test_blob(void)
1121 {
1122         side_event_enable__my_provider_event_blob = 1;
1123         side_event_cond(my_provider_event_blob) {
1124                 side_arg_define_vec(myarray, side_arg_list(side_arg_byte(1), side_arg_byte(2), side_arg_byte(3)));
1125                 side_arg_dynamic_define_vec(myvla,
1126                         side_arg_list(
1127                                 side_arg_dynamic_byte(0x22, side_attr_list()),
1128                                 side_arg_dynamic_byte(0x33, side_attr_list()),
1129                         ),
1130                         side_attr_list()
1131                 );
1132                 side_event_call_variadic(my_provider_event_blob,
1133                         side_arg_list(
1134                                 side_arg_byte(0x55),
1135                                 side_arg_array(&myarray),
1136                                 side_arg_array_byte(blob_fixint),
1137                                 side_arg_vla_byte(blob_fixint, SIDE_ARRAY_SIZE(blob_fixint)),
1138                         ),
1139                         side_arg_list(
1140                                 side_arg_dynamic_field("varblobfield",
1141                                         side_arg_dynamic_byte(0x55, side_attr_list())
1142                                 ),
1143                                 side_arg_dynamic_field("varblobvla", side_arg_dynamic_vla(&myvla)),
1144                         ),
1145                         side_attr_list()
1146                 );
1147         }
1148 }
1149
1150 side_static_event_variadic(my_provider_event_format_string,
1151         "myprovider", "myeventformatstring", SIDE_LOGLEVEL_DEBUG,
1152         side_field_list(
1153                 side_field_string("fmt", side_attr_list()),
1154         ),
1155         side_attr_list(
1156                 side_attr("lang.c.format_string", side_attr_bool(true)),
1157         )
1158 );
1159
1160 static
1161 void test_fmt_string(void)
1162 {
1163         side_event_enable__my_provider_event_format_string = 1;
1164         side_event_cond(my_provider_event_format_string) {
1165                 side_arg_dynamic_define_vec(args,
1166                         side_arg_list(
1167                                 side_arg_dynamic_string("blah", side_attr_list()),
1168                                 side_arg_dynamic_s32(123, side_attr_list()),
1169                         ),
1170                         side_attr_list()
1171                 );
1172                 side_event_call_variadic(my_provider_event_format_string,
1173                         side_arg_list(
1174                                 side_arg_string("This is a formatted string with str: %s int: %d"),
1175                         ),
1176                         side_arg_list(
1177                                 side_arg_dynamic_field("arguments", side_arg_dynamic_vla(&args)),
1178                         ),
1179                         side_attr_list()
1180                 );
1181         }
1182 }
1183
1184 int main()
1185 {
1186         test_fields();
1187         test_event_hidden();
1188         test_event_export();
1189         test_struct_literal();
1190         test_struct();
1191         test_array();
1192         test_vla();
1193         test_vla_visitor();
1194         test_vla_visitor_2d();
1195         test_array_fixint();
1196         test_vla_fixint();
1197         test_dynamic_basic_type();
1198         test_dynamic_vla();
1199         test_dynamic_null();
1200         test_dynamic_struct();
1201         test_dynamic_nested_struct();
1202         test_dynamic_vla_struct();
1203         test_dynamic_struct_vla();
1204         test_dynamic_nested_vla();
1205         test_variadic();
1206         test_static_variadic();
1207         test_bool();
1208         test_dynamic_bool();
1209         test_dynamic_vla_with_visitor();
1210         test_dynamic_struct_with_visitor();
1211         test_event_user_attribute();
1212         test_field_user_attribute();
1213         test_variadic_attr();
1214         test_variadic_vla_attr();
1215         test_variadic_struct_attr();
1216         test_float();
1217         test_variadic_float();
1218         test_enum();
1219         test_enum_bitmap();
1220         test_blob();
1221         test_fmt_string();
1222         return 0;
1223 }