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 #include <stddef.h>
  12
  13 #include <side/trace.h>
  14 #include "tracer.h"
  15
  16 /* User code example */
  17
  18 side_static_event(my_provider_event, "myprovider", "myevent", SIDE_LOGLEVEL_DEBUG,
  19         side_field_list(
  20                 side_field_u32("abc", side_attr_list()),
  21                 side_field_s64("def", side_attr_list()),
  22                 side_field_pointer("ptr", side_attr_list()),
  23                 side_field_dynamic("dynamic"),
  24                 side_field_dynamic("dynamic_pointer"),
  25                 side_field_null("null", side_attr_list()),
  26         ),
  27         side_attr_list()
  28 );
  29
  30 static
  31 void test_fields(void)
  32 {
  33         uint32_t uw = 42;
  34         int64_t sdw = -500;
  35
  36         side_event(my_provider_event,
  37                 side_arg_list(
  38                         side_arg_u32(uw),
  39                         side_arg_s64(sdw),
  40                         side_arg_pointer((void *) 0x1),
  41                         side_arg_dynamic_string("zzz", side_attr_list()),
  42                         side_arg_dynamic_pointer((void *) 0x1, side_attr_list()),
  43                         side_arg_null(),
  44                 )
  45         );
  46 }
  47
  48 side_hidden_event(my_provider_event_hidden, "myprovider", "myeventhidden", SIDE_LOGLEVEL_DEBUG,
  49         side_field_list(
  50                 side_field_u32("abc", side_attr_list()),
  51         ),
  52         side_attr_list()
  53 );
  54
  55 static
  56 void test_event_hidden(void)
  57 {
  58         side_event(my_provider_event_hidden, side_arg_list(side_arg_u32(2)));
  59 }
  60
  61 side_declare_event(my_provider_event_export);
  62
  63 side_export_event(my_provider_event_export, "myprovider", "myeventexport", SIDE_LOGLEVEL_DEBUG,
  64         side_field_list(
  65                 side_field_u32("abc", side_attr_list()),
  66         ),
  67         side_attr_list()
  68 );
  69
  70 static
  71 void test_event_export(void)
  72 {
  73         side_event(my_provider_event_export, side_arg_list(side_arg_u32(2)));
  74 }
  75
  76 side_static_event(my_provider_event_struct_literal, "myprovider", "myeventstructliteral", SIDE_LOGLEVEL_DEBUG,
  77         side_field_list(
  78                 side_field_struct("structliteral",
  79                         side_struct_literal(
  80                                 side_field_list(
  81                                         side_field_u32("x", side_attr_list()),
  82                                         side_field_s64("y", side_attr_list()),
  83                                 ),
  84                                 side_attr_list()
  85                         )
  86                 ),
  87                 side_field_u8("z", side_attr_list()),
  88         ),
  89         side_attr_list()
  90 );
  91
  92 static
  93 void test_struct_literal(void)
  94 {
  95         side_event_cond(my_provider_event_struct_literal) {
  96                 side_arg_define_vec(mystruct, side_arg_list(side_arg_u32(21), side_arg_s64(22)));
  97                 side_event_call(my_provider_event_struct_literal, side_arg_list(side_arg_struct(&mystruct), side_arg_u8(55)));
  98         }
  99 }
 100
 101 static side_define_struct(mystructdef,
 102         side_field_list(
 103                 side_field_u32("x", side_attr_list()),
 104                 side_field_s64("y", side_attr_list()),
 105         ),
 106         side_attr_list()
 107 );
 108
 109 side_static_event(my_provider_event_struct, "myprovider", "myeventstruct", SIDE_LOGLEVEL_DEBUG,
 110         side_field_list(
 111                 side_field_struct("struct", &mystructdef),
 112                 side_field_u8("z", side_attr_list()),
 113         ),
 114         side_attr_list()
 115 );
 116
 117 static
 118 void test_struct(void)
 119 {
 120         side_event_cond(my_provider_event_struct) {
 121                 side_arg_define_vec(mystruct, side_arg_list(side_arg_u32(21), side_arg_s64(22)));
 122                 side_event_call(my_provider_event_struct, side_arg_list(side_arg_struct(&mystruct), side_arg_u8(55)));
 123         }
 124 }
 125
 126 side_static_event(my_provider_event_array, "myprovider", "myarray", SIDE_LOGLEVEL_DEBUG,
 127         side_field_list(
 128                 side_field_array("arr", side_elem(side_type_u32(side_attr_list())), 3, side_attr_list()),
 129                 side_field_s64("v", side_attr_list()),
 130         ),
 131         side_attr_list()
 132 );
 133
 134 static
 135 void test_array(void)
 136 {
 137         side_event_cond(my_provider_event_array) {
 138                 side_arg_define_vec(myarray, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
 139                 side_event_call(my_provider_event_array, side_arg_list(side_arg_array(&myarray), side_arg_s64(42)));
 140         }
 141 }
 142
 143 side_static_event(my_provider_event_vla, "myprovider", "myvla", SIDE_LOGLEVEL_DEBUG,
 144         side_field_list(
 145                 side_field_vla("vla", side_elem(side_type_u32(side_attr_list())), side_attr_list()),
 146                 side_field_s64("v", side_attr_list()),
 147         ),
 148         side_attr_list()
 149 );
 150
 151 static
 152 void test_vla(void)
 153 {
 154         side_event_cond(my_provider_event_vla) {
 155                 side_arg_define_vec(myvla, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
 156                 side_event_call(my_provider_event_vla, side_arg_list(side_arg_vla(&myvla), side_arg_s64(42)));
 157         }
 158 }
 159
 160 /* 1D array visitor */
 161
 162 struct app_visitor_ctx {
 163         const uint32_t *ptr;
 164         uint32_t length;
 165 };
 166
 167 static
 168 enum side_visitor_status test_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 169 {
 170         struct app_visitor_ctx *ctx = (struct app_visitor_ctx *) _ctx;
 171         uint32_t length = ctx->length, i;
 172
 173         for (i = 0; i < length; i++) {
 174                 const struct side_arg elem = side_arg_u32(ctx->ptr[i]);
 175
 176                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 177                         return SIDE_VISITOR_STATUS_ERROR;
 178         }
 179         return SIDE_VISITOR_STATUS_OK;
 180 }
 181
 182 static uint32_t testarray[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 183
 184 side_static_event(my_provider_event_vla_visitor, "myprovider", "myvlavisit", SIDE_LOGLEVEL_DEBUG,
 185         side_field_list(
 186                 side_field_vla_visitor("vlavisit", side_elem(side_type_u32(side_attr_list())), test_visitor, side_attr_list()),
 187                 side_field_s64("v", side_attr_list()),
 188         ),
 189         side_attr_list()
 190 );
 191
 192 static
 193 void test_vla_visitor(void)
 194 {
 195         side_event_cond(my_provider_event_vla_visitor) {
 196                 struct app_visitor_ctx ctx = {
 197                         .ptr = testarray,
 198                         .length = SIDE_ARRAY_SIZE(testarray),
 199                 };
 200                 side_event_call(my_provider_event_vla_visitor, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
 201         }
 202 }
 203
 204 /* 2D array visitor */
 205
 206 struct app_visitor_2d_inner_ctx {
 207         const uint32_t *ptr;
 208         uint32_t length;
 209 };
 210
 211 static
 212 enum side_visitor_status test_inner_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 213 {
 214         struct app_visitor_2d_inner_ctx *ctx = (struct app_visitor_2d_inner_ctx *) _ctx;
 215         uint32_t length = ctx->length, i;
 216
 217         for (i = 0; i < length; i++) {
 218                 const struct side_arg elem = side_arg_u32(ctx->ptr[i]);
 219
 220                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 221                         return SIDE_VISITOR_STATUS_ERROR;
 222         }
 223         return SIDE_VISITOR_STATUS_OK;
 224 }
 225
 226 struct app_visitor_2d_outer_ctx {
 227         const uint32_t (*ptr)[2];
 228         uint32_t length;
 229 };
 230
 231 static
 232 enum side_visitor_status test_outer_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 233 {
 234         struct app_visitor_2d_outer_ctx *ctx = (struct app_visitor_2d_outer_ctx *) _ctx;
 235         uint32_t length = ctx->length, i;
 236
 237         for (i = 0; i < length; i++) {
 238                 struct app_visitor_2d_inner_ctx inner_ctx = {
 239                         .ptr = ctx->ptr[i],
 240                         .length = 2,
 241                 };
 242                 const struct side_arg elem = side_arg_vla_visitor(&inner_ctx);
 243                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 244                         return SIDE_VISITOR_STATUS_ERROR;
 245         }
 246         return SIDE_VISITOR_STATUS_OK;
 247 }
 248
 249 static uint32_t testarray2d[][2] = {
 250         { 1, 2 },
 251         { 33, 44 },
 252         { 55, 66 },
 253 };
 254
 255 side_static_event(my_provider_event_vla_visitor2d, "myprovider", "myvlavisit2d", SIDE_LOGLEVEL_DEBUG,
 256         side_field_list(
 257                 side_field_vla_visitor("vlavisit2d",
 258                         side_elem(
 259                                 side_type_vla_visitor(
 260                                         side_elem(side_type_u32(side_attr_list())),
 261                                         test_inner_visitor,
 262                                         side_attr_list())
 263                         ), test_outer_visitor, side_attr_list()),
 264                 side_field_s64("v", side_attr_list()),
 265         ),
 266         side_attr_list()
 267 );
 268
 269 static
 270 void test_vla_visitor_2d(void)
 271 {
 272         side_event_cond(my_provider_event_vla_visitor2d) {
 273                 struct app_visitor_2d_outer_ctx ctx = {
 274                         .ptr = testarray2d,
 275                         .length = SIDE_ARRAY_SIZE(testarray2d),
 276                 };
 277                 side_event_call(my_provider_event_vla_visitor2d, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
 278         }
 279 }
 280
 281 static int64_t array_fixint[] = { -444, 555, 123, 2897432587 };
 282
 283 side_static_event(my_provider_event_array_fixint, "myprovider", "myarrayfixint", SIDE_LOGLEVEL_DEBUG,
 284         side_field_list(
 285                 side_field_array("arrfixint", side_elem(side_type_s64(side_attr_list())), SIDE_ARRAY_SIZE(array_fixint), side_attr_list()),
 286                 side_field_s64("v", side_attr_list()),
 287         ),
 288         side_attr_list()
 289 );
 290
 291 static
 292 void test_array_fixint(void)
 293 {
 294         side_event(my_provider_event_array_fixint,
 295                 side_arg_list(side_arg_array_s64(array_fixint), side_arg_s64(42)));
 296 }
 297
 298 static int64_t vla_fixint[] = { -444, 555, 123, 2897432587 };
 299
 300 side_static_event(my_provider_event_vla_fixint, "myprovider", "myvlafixint", SIDE_LOGLEVEL_DEBUG,
 301         side_field_list(
 302                 side_field_vla("vlafixint", side_elem(side_type_s64(side_attr_list())), side_attr_list()),
 303                 side_field_s64("v", side_attr_list()),
 304         ),
 305         side_attr_list()
 306 );
 307
 308 static
 309 void test_vla_fixint(void)
 310 {
 311         side_event(my_provider_event_vla_fixint,
 312                 side_arg_list(side_arg_vla_s64(vla_fixint, SIDE_ARRAY_SIZE(vla_fixint)), side_arg_s64(42)));
 313 }
 314
 315 side_static_event(my_provider_event_dynamic_basic,
 316         "myprovider", "mydynamicbasic", SIDE_LOGLEVEL_DEBUG,
 317         side_field_list(
 318                 side_field_dynamic("dynamic"),
 319         ),
 320         side_attr_list()
 321 );
 322
 323 static
 324 void test_dynamic_basic_type(void)
 325 {
 326         side_event(my_provider_event_dynamic_basic,
 327                 side_arg_list(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"),
 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(my_provider_event_dynamic_vla,
 350                 side_arg_list(side_arg_dynamic_vla(&myvla)));
 351 }
 352
 353 side_static_event(my_provider_event_dynamic_null,
 354         "myprovider", "mydynamicnull", SIDE_LOGLEVEL_DEBUG,
 355         side_field_list(
 356                 side_field_dynamic("dynamic"),
 357         ),
 358         side_attr_list()
 359 );
 360
 361 static
 362 void test_dynamic_null(void)
 363 {
 364         side_event(my_provider_event_dynamic_null,
 365                 side_arg_list(side_arg_dynamic_null(side_attr_list())));
 366 }
 367
 368 side_static_event(my_provider_event_dynamic_struct,
 369         "myprovider", "mydynamicstruct", SIDE_LOGLEVEL_DEBUG,
 370         side_field_list(
 371                 side_field_dynamic("dynamic"),
 372         ),
 373         side_attr_list()
 374 );
 375
 376 static
 377 void test_dynamic_struct(void)
 378 {
 379         side_arg_dynamic_define_struct(mystruct,
 380                 side_arg_list(
 381                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
 382                         side_arg_dynamic_field("b", side_arg_dynamic_string("zzz", side_attr_list())),
 383                         side_arg_dynamic_field("c", side_arg_dynamic_null(side_attr_list())),
 384                 ),
 385                 side_attr_list()
 386         );
 387
 388         side_event(my_provider_event_dynamic_struct,
 389                 side_arg_list(side_arg_dynamic_struct(&mystruct)));
 390 }
 391
 392 side_static_event(my_provider_event_dynamic_nested_struct,
 393         "myprovider", "mydynamicnestedstruct", SIDE_LOGLEVEL_DEBUG,
 394         side_field_list(
 395                 side_field_dynamic("dynamic"),
 396         ),
 397         side_attr_list()
 398 );
 399
 400 static
 401 void test_dynamic_nested_struct(void)
 402 {
 403         side_arg_dynamic_define_struct(nested,
 404                 side_arg_list(
 405                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
 406                         side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
 407                 ),
 408                 side_attr_list()
 409         );
 410         side_arg_dynamic_define_struct(nested2,
 411                 side_arg_list(
 412                         side_arg_dynamic_field("aa", side_arg_dynamic_u64(128, side_attr_list())),
 413                         side_arg_dynamic_field("bb", side_arg_dynamic_u16(1, side_attr_list())),
 414                 ),
 415                 side_attr_list()
 416         );
 417         side_arg_dynamic_define_struct(mystruct,
 418                 side_arg_list(
 419                         side_arg_dynamic_field("nested", side_arg_dynamic_struct(&nested)),
 420                         side_arg_dynamic_field("nested2", side_arg_dynamic_struct(&nested2)),
 421                 ),
 422                 side_attr_list()
 423         );
 424         side_event(my_provider_event_dynamic_nested_struct,
 425                 side_arg_list(side_arg_dynamic_struct(&mystruct)));
 426 }
 427
 428 side_static_event(my_provider_event_dynamic_vla_struct,
 429         "myprovider", "mydynamicvlastruct", SIDE_LOGLEVEL_DEBUG,
 430         side_field_list(
 431                 side_field_dynamic("dynamic"),
 432         ),
 433         side_attr_list()
 434 );
 435
 436 static
 437 void test_dynamic_vla_struct(void)
 438 {
 439         side_arg_dynamic_define_struct(nested,
 440                 side_arg_list(
 441                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
 442                         side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
 443                 ),
 444                 side_attr_list()
 445         );
 446         side_arg_dynamic_define_vec(myvla,
 447                 side_arg_list(
 448                         side_arg_dynamic_struct(&nested),
 449                         side_arg_dynamic_struct(&nested),
 450                         side_arg_dynamic_struct(&nested),
 451                         side_arg_dynamic_struct(&nested),
 452                 ),
 453                 side_attr_list()
 454         );
 455         side_event(my_provider_event_dynamic_vla_struct,
 456                 side_arg_list(side_arg_dynamic_vla(&myvla)));
 457 }
 458
 459 side_static_event(my_provider_event_dynamic_struct_vla,
 460         "myprovider", "mydynamicstructvla", SIDE_LOGLEVEL_DEBUG,
 461         side_field_list(
 462                 side_field_dynamic("dynamic"),
 463         ),
 464         side_attr_list()
 465 );
 466
 467 static
 468 void test_dynamic_struct_vla(void)
 469 {
 470         side_arg_dynamic_define_vec(myvla,
 471                 side_arg_list(
 472                         side_arg_dynamic_u32(1, side_attr_list()),
 473                         side_arg_dynamic_u32(2, side_attr_list()),
 474                         side_arg_dynamic_u32(3, side_attr_list()),
 475                 ),
 476                 side_attr_list()
 477         );
 478         side_arg_dynamic_define_vec(myvla2,
 479                 side_arg_list(
 480                         side_arg_dynamic_u32(4, side_attr_list()),
 481                         side_arg_dynamic_u64(5, side_attr_list()),
 482                         side_arg_dynamic_u32(6, side_attr_list()),
 483                 ),
 484                 side_attr_list()
 485         );
 486         side_arg_dynamic_define_struct(mystruct,
 487                 side_arg_list(
 488                         side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla)),
 489                         side_arg_dynamic_field("b", side_arg_dynamic_vla(&myvla2)),
 490                 ),
 491                 side_attr_list()
 492         );
 493         side_event(my_provider_event_dynamic_struct_vla,
 494                 side_arg_list(side_arg_dynamic_struct(&mystruct)));
 495 }
 496
 497 side_static_event(my_provider_event_dynamic_nested_vla,
 498         "myprovider", "mydynamicnestedvla", SIDE_LOGLEVEL_DEBUG,
 499         side_field_list(
 500                 side_field_dynamic("dynamic"),
 501         ),
 502         side_attr_list()
 503 );
 504
 505 static
 506 void test_dynamic_nested_vla(void)
 507 {
 508         side_arg_dynamic_define_vec(nestedvla,
 509                 side_arg_list(
 510                         side_arg_dynamic_u32(1, side_attr_list()),
 511                         side_arg_dynamic_u16(2, side_attr_list()),
 512                         side_arg_dynamic_u32(3, side_attr_list()),
 513                 ),
 514                 side_attr_list()
 515         );
 516         side_arg_dynamic_define_vec(nestedvla2,
 517                 side_arg_list(
 518                         side_arg_dynamic_u8(4, side_attr_list()),
 519                         side_arg_dynamic_u32(5, side_attr_list()),
 520                         side_arg_dynamic_u32(6, side_attr_list()),
 521                 ),
 522                 side_attr_list()
 523         );
 524         side_arg_dynamic_define_vec(myvla,
 525                 side_arg_list(
 526                         side_arg_dynamic_vla(&nestedvla),
 527                         side_arg_dynamic_vla(&nestedvla2),
 528                 ),
 529                 side_attr_list()
 530         );
 531         side_event(my_provider_event_dynamic_nested_vla,
 532                 side_arg_list(side_arg_dynamic_vla(&myvla)));
 533 }
 534
 535 side_static_event_variadic(my_provider_event_variadic,
 536         "myprovider", "myvariadicevent", SIDE_LOGLEVEL_DEBUG,
 537         side_field_list(),
 538         side_attr_list()
 539 );
 540
 541 static
 542 void test_variadic(void)
 543 {
 544         side_event_variadic(my_provider_event_variadic,
 545                 side_arg_list(),
 546                 side_arg_list(
 547                         side_arg_dynamic_field("a", side_arg_dynamic_u32(55, side_attr_list())),
 548                         side_arg_dynamic_field("b", side_arg_dynamic_s8(-4, side_attr_list())),
 549                 ),
 550                 side_attr_list()
 551         );
 552 }
 553
 554 side_static_event_variadic(my_provider_event_static_variadic,
 555         "myprovider", "mystaticvariadicevent", SIDE_LOGLEVEL_DEBUG,
 556         side_field_list(
 557                 side_field_u32("abc", side_attr_list()),
 558                 side_field_u16("def", side_attr_list()),
 559         ),
 560         side_attr_list()
 561 );
 562
 563 static
 564 void test_static_variadic(void)
 565 {
 566         side_event_variadic(my_provider_event_static_variadic,
 567                 side_arg_list(
 568                         side_arg_u32(1),
 569                         side_arg_u16(2),
 570                 ),
 571                 side_arg_list(
 572                         side_arg_dynamic_field("a", side_arg_dynamic_u32(55, side_attr_list())),
 573                         side_arg_dynamic_field("b", side_arg_dynamic_s8(-4, side_attr_list())),
 574                 ),
 575                 side_attr_list()
 576         );
 577 }
 578
 579 side_static_event(my_provider_event_bool, "myprovider", "myeventbool", SIDE_LOGLEVEL_DEBUG,
 580         side_field_list(
 581                 side_field_bool("a_false", side_attr_list()),
 582                 side_field_bool("b_true", side_attr_list()),
 583                 side_field_bool("c_true", side_attr_list()),
 584                 side_field_bool("d_true", side_attr_list()),
 585                 side_field_bool("e_true", side_attr_list()),
 586                 side_field_bool("f_false", side_attr_list()),
 587                 side_field_bool("g_true", side_attr_list()),
 588         ),
 589         side_attr_list()
 590 );
 591
 592 static
 593 void test_bool(void)
 594 {
 595         uint32_t a = 0;
 596         uint32_t b = 1;
 597         uint64_t c = 0x12345678;
 598         int16_t d = -32768;
 599         bool e = true;
 600         bool f = false;
 601         uint32_t g = 256;
 602
 603         side_event(my_provider_event_bool,
 604                 side_arg_list(
 605                         side_arg_bool(a),
 606                         side_arg_bool(b),
 607                         side_arg_bool(c),
 608                         side_arg_bool(d),
 609                         side_arg_bool(e),
 610                         side_arg_bool(f),
 611                         side_arg_bool(g),
 612                 )
 613         );
 614 }
 615
 616 side_static_event_variadic(my_provider_event_dynamic_bool,
 617         "myprovider", "mydynamicbool", SIDE_LOGLEVEL_DEBUG,
 618         side_field_list(),
 619         side_attr_list()
 620 );
 621
 622 static
 623 void test_dynamic_bool(void)
 624 {
 625         side_event_variadic(my_provider_event_dynamic_bool,
 626                 side_arg_list(),
 627                 side_arg_list(
 628                         side_arg_dynamic_field("a_true", side_arg_dynamic_bool(55, side_attr_list())),
 629                         side_arg_dynamic_field("b_true", side_arg_dynamic_bool(-4, side_attr_list())),
 630                         side_arg_dynamic_field("c_false", side_arg_dynamic_bool(0, side_attr_list())),
 631                         side_arg_dynamic_field("d_true", side_arg_dynamic_bool(256, side_attr_list())),
 632                 ),
 633                 side_attr_list()
 634         );
 635 }
 636
 637 side_static_event(my_provider_event_dynamic_vla_visitor,
 638         "myprovider", "mydynamicvlavisitor", SIDE_LOGLEVEL_DEBUG,
 639         side_field_list(
 640                 side_field_dynamic("dynamic"),
 641         ),
 642         side_attr_list()
 643 );
 644
 645 struct app_dynamic_vla_visitor_ctx {
 646         const uint32_t *ptr;
 647         uint32_t length;
 648 };
 649
 650 static
 651 enum side_visitor_status test_dynamic_vla_visitor(const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx, void *_ctx)
 652 {
 653         struct app_dynamic_vla_visitor_ctx *ctx = (struct app_dynamic_vla_visitor_ctx *) _ctx;
 654         uint32_t length = ctx->length, i;
 655
 656         for (i = 0; i < length; i++) {
 657                 const struct side_arg elem = {
 658                         .type = SIDE_TYPE_DYNAMIC_U32,
 659                         .u = {
 660                                 .side_dynamic = {
 661                                         .side_integer = {
 662                                                 .type = {
 663                                                         .attr = NULL,
 664                                                         .nr_attr = 0,
 665                                                         .integer_size_bits = 32,
 666                                                         .len_bits = 32,
 667                                                         .signedness = false,
 668                                                         .byte_order = SIDE_TYPE_BYTE_ORDER_HOST,
 669                                                 },
 670                                                 .value = {
 671                                                         .side_u32 = ctx->ptr[i],
 672                                                 },
 673                                         },
 674                                 },
 675                         },
 676                 };
 677                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 678                         return SIDE_VISITOR_STATUS_ERROR;
 679         }
 680         return SIDE_VISITOR_STATUS_OK;
 681 }
 682
 683 static uint32_t testarray_dynamic_vla[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 684
 685 static
 686 void test_dynamic_vla_with_visitor(void)
 687 {
 688         side_event_cond(my_provider_event_dynamic_vla_visitor) {
 689                 struct app_dynamic_vla_visitor_ctx ctx = {
 690                         .ptr = testarray_dynamic_vla,
 691                         .length = SIDE_ARRAY_SIZE(testarray_dynamic_vla),
 692                 };
 693                 side_event_call(my_provider_event_dynamic_vla_visitor,
 694                         side_arg_list(
 695                                 side_arg_dynamic_vla_visitor(test_dynamic_vla_visitor, &ctx, side_attr_list())
 696                         )
 697                 );
 698         }
 699 }
 700
 701 side_static_event(my_provider_event_dynamic_struct_visitor,
 702         "myprovider", "mydynamicstructvisitor", SIDE_LOGLEVEL_DEBUG,
 703         side_field_list(
 704                 side_field_dynamic("dynamic"),
 705         ),
 706         side_attr_list()
 707 );
 708
 709 struct struct_visitor_pair {
 710         const char *name;
 711         uint32_t value;
 712 };
 713
 714 struct app_dynamic_struct_visitor_ctx {
 715         const struct struct_visitor_pair *ptr;
 716         uint32_t length;
 717 };
 718
 719 static
 720 enum side_visitor_status test_dynamic_struct_visitor(const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx, void *_ctx)
 721 {
 722         struct app_dynamic_struct_visitor_ctx *ctx = (struct app_dynamic_struct_visitor_ctx *) _ctx;
 723         uint32_t length = ctx->length, i;
 724
 725         for (i = 0; i < length; i++) {
 726                 struct side_arg_dynamic_event_field dynamic_field = {
 727                         .field_name = ctx->ptr[i].name,
 728                         .elem = {
 729                                 .type = SIDE_TYPE_DYNAMIC_U32,
 730                                 .u = {
 731                                         .side_dynamic = {
 732                                                 .side_integer = {
 733                                                         .type = {
 734                                                                 .attr = NULL,
 735                                                                 .nr_attr = 0,
 736                                                                 .integer_size_bits = 32,
 737                                                                 .len_bits = 32,
 738                                                                 .signedness = false,
 739                                                                 .byte_order = SIDE_TYPE_BYTE_ORDER_HOST,
 740                                                         },
 741                                                         .value = {
 742                                                                 .side_u32 = ctx->ptr[i].value,
 743                                                         },
 744                                                 },
 745                                         },
 746                                 },
 747                         },
 748                 };
 749                 if (tracer_ctx->write_field(tracer_ctx, &dynamic_field) != SIDE_VISITOR_STATUS_OK)
 750                         return SIDE_VISITOR_STATUS_ERROR;
 751         }
 752         return SIDE_VISITOR_STATUS_OK;
 753 }
 754
 755 static struct struct_visitor_pair testarray_dynamic_struct[] = {
 756         { "a", 1, },
 757         { "b", 2, },
 758         { "c", 3, },
 759         { "d", 4, },
 760 };
 761
 762 static
 763 void test_dynamic_struct_with_visitor(void)
 764 {
 765         side_event_cond(my_provider_event_dynamic_struct_visitor) {
 766                 struct app_dynamic_struct_visitor_ctx ctx = {
 767                         .ptr = testarray_dynamic_struct,
 768                         .length = SIDE_ARRAY_SIZE(testarray_dynamic_struct),
 769                 };
 770                 side_event_call(my_provider_event_dynamic_struct_visitor,
 771                         side_arg_list(
 772                                 side_arg_dynamic_struct_visitor(test_dynamic_struct_visitor, &ctx, side_attr_list())
 773                         )
 774                 );
 775         }
 776 }
 777
 778 side_static_event(my_provider_event_user_attribute, "myprovider", "myevent_user_attribute", SIDE_LOGLEVEL_DEBUG,
 779         side_field_list(
 780                 side_field_u32("abc", side_attr_list()),
 781                 side_field_s64("def", side_attr_list()),
 782         ),
 783         side_attr_list(
 784                 side_attr("user_attribute_a", side_attr_string("val1")),
 785                 side_attr("user_attribute_b", side_attr_string("val2")),
 786         )
 787 );
 788
 789 static
 790 void test_event_user_attribute(void)
 791 {
 792         side_event(my_provider_event_user_attribute, side_arg_list(side_arg_u32(1), side_arg_s64(2)));
 793 }
 794
 795 side_static_event(my_provider_field_user_attribute, "myprovider", "myevent_field_attribute", SIDE_LOGLEVEL_DEBUG,
 796         side_field_list(
 797                 side_field_u32("abc",
 798                         side_attr_list(
 799                                 side_attr("user_attribute_a", side_attr_string("val1")),
 800                                 side_attr("user_attribute_b", side_attr_u32(2)),
 801                         )
 802                 ),
 803                 side_field_s64("def",
 804                         side_attr_list(
 805                                 side_attr("user_attribute_c", side_attr_string("val3")),
 806                                 side_attr("user_attribute_d", side_attr_s64(-5)),
 807                         )
 808                 ),
 809         ),
 810         side_attr_list()
 811 );
 812
 813 static
 814 void test_field_user_attribute(void)
 815 {
 816         side_event(my_provider_field_user_attribute, side_arg_list(side_arg_u32(1), side_arg_s64(2)));
 817 }
 818
 819 side_static_event_variadic(my_provider_event_variadic_attr,
 820         "myprovider", "myvariadiceventattr", SIDE_LOGLEVEL_DEBUG,
 821         side_field_list(),
 822         side_attr_list()
 823 );
 824
 825 static
 826 void test_variadic_attr(void)
 827 {
 828         side_event_variadic(my_provider_event_variadic_attr,
 829                 side_arg_list(),
 830                 side_arg_list(
 831                         side_arg_dynamic_field("a",
 832                                 side_arg_dynamic_u32(55,
 833                                         side_attr_list(
 834                                                 side_attr("user_attribute_c", side_attr_string("valX")),
 835                                                 side_attr("user_attribute_d", side_attr_u8(55)),
 836                                         )
 837                                 )
 838                         ),
 839                         side_arg_dynamic_field("b",
 840                                 side_arg_dynamic_s8(-4,
 841                                         side_attr_list(
 842                                                 side_attr("X", side_attr_u8(1)),
 843                                                 side_attr("Y", side_attr_s8(2)),
 844                                         )
 845                                 )
 846                         ),
 847                 ),
 848                 side_attr_list()
 849         );
 850 }
 851
 852 side_static_event_variadic(my_provider_event_variadic_vla_attr,
 853         "myprovider", "myvariadiceventvlaattr", SIDE_LOGLEVEL_DEBUG,
 854         side_field_list(),
 855         side_attr_list()
 856 );
 857
 858 static
 859 void test_variadic_vla_attr(void)
 860 {
 861         side_arg_dynamic_define_vec(myvla,
 862                 side_arg_list(
 863                         side_arg_dynamic_u32(1,
 864                                 side_attr_list(
 865                                         side_attr("Z", side_attr_u8(0)),
 866                                         side_attr("A", side_attr_u8(123)),
 867                                 )
 868                         ),
 869                         side_arg_dynamic_u32(2, side_attr_list()),
 870                         side_arg_dynamic_u32(3, side_attr_list()),
 871                 ),
 872                 side_attr_list(
 873                         side_attr("X", side_attr_u8(1)),
 874                         side_attr("Y", side_attr_u8(2)),
 875                 )
 876         );
 877         side_event_variadic(my_provider_event_variadic_vla_attr,
 878                 side_arg_list(),
 879                 side_arg_list(
 880                         side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla)),
 881                 ),
 882                 side_attr_list()
 883         );
 884 }
 885
 886 side_static_event_variadic(my_provider_event_variadic_struct_attr,
 887         "myprovider", "myvariadiceventstructattr", SIDE_LOGLEVEL_DEBUG,
 888         side_field_list(),
 889         side_attr_list()
 890 );
 891
 892 static
 893 void test_variadic_struct_attr(void)
 894 {
 895         side_event_cond(my_provider_event_variadic_struct_attr) {
 896                 side_arg_dynamic_define_struct(mystruct,
 897                         side_arg_list(
 898                                 side_arg_dynamic_field("a",
 899                                         side_arg_dynamic_u32(43,
 900                                                 side_attr_list(
 901                                                         side_attr("A", side_attr_bool(true)),
 902                                                 )
 903                                         )
 904                                 ),
 905                                 side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
 906                         ),
 907                         side_attr_list(
 908                                 side_attr("X", side_attr_u8(1)),
 909                                 side_attr("Y", side_attr_u8(2)),
 910                         )
 911                 );
 912                 side_event_call_variadic(my_provider_event_variadic_struct_attr,
 913                         side_arg_list(),
 914                         side_arg_list(
 915                                 side_arg_dynamic_field("a", side_arg_dynamic_struct(&mystruct)),
 916                         ),
 917                         side_attr_list()
 918                 );
 919         }
 920 }
 921
 922 side_static_event(my_provider_event_float, "myprovider", "myeventfloat", SIDE_LOGLEVEL_DEBUG,
 923         side_field_list(
 924 #if __HAVE_FLOAT16
 925                 side_field_float_binary16("binary16", side_attr_list()),
 926                 side_field_float_binary16_le("binary16_le", side_attr_list()),
 927                 side_field_float_binary16_be("binary16_be", side_attr_list()),
 928 #endif
 929 #if __HAVE_FLOAT32
 930                 side_field_float_binary32("binary32", side_attr_list()),
 931                 side_field_float_binary32_le("binary32_le", side_attr_list()),
 932                 side_field_float_binary32_be("binary32_be", side_attr_list()),
 933 #endif
 934 #if __HAVE_FLOAT64
 935                 side_field_float_binary64("binary64", side_attr_list()),
 936                 side_field_float_binary64_le("binary64_le", side_attr_list()),
 937                 side_field_float_binary64_be("binary64_be", side_attr_list()),
 938 #endif
 939 #if __HAVE_FLOAT128
 940                 side_field_float_binary128("binary128", side_attr_list()),
 941                 side_field_float_binary128_le("binary128_le", side_attr_list()),
 942                 side_field_float_binary128_be("binary128_be", side_attr_list()),
 943 #endif
 944         ),
 945         side_attr_list()
 946 );
 947
 948 static
 949 void test_float(void)
 950 {
 951 #if __HAVE_FLOAT16
 952         union {
 953                 _Float16 f;
 954                 uint16_t u;
 955         } float16 = {
 956                 .f = 1.1,
 957         };
 958 #endif
 959 #if __HAVE_FLOAT32
 960         union {
 961                 _Float32 f;
 962                 uint32_t u;
 963         } float32 = {
 964                 .f = 2.2,
 965         };
 966 #endif
 967 #if __HAVE_FLOAT64
 968         union {
 969                 _Float64 f;
 970                 uint64_t u;
 971         } float64 = {
 972                 .f = 3.3,
 973         };
 974 #endif
 975 #if __HAVE_FLOAT128
 976         union {
 977                 _Float128 f;
 978                 char arr[16];
 979         } float128 = {
 980                 .f = 4.4,
 981         };
 982 #endif
 983
 984 #if __HAVE_FLOAT16
 985         float16.u = side_bswap_16(float16.u);
 986 #endif
 987 #if __HAVE_FLOAT32
 988         float32.u = side_bswap_32(float32.u);
 989 #endif
 990 #if __HAVE_FLOAT64
 991         float64.u = side_bswap_64(float64.u);
 992 #endif
 993 #if __HAVE_FLOAT128
 994         side_bswap_128p(float128.arr);
 995 #endif
 996
 997         side_event(my_provider_event_float,
 998                 side_arg_list(
 999 #if __HAVE_FLOAT16
1000                         side_arg_float_binary16(1.1),
1001 # if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
1002                         side_arg_float_binary16(1.1),
1003                         side_arg_float_binary16(float16.f),
1004 # else
1005                         side_arg_float_binary16(float16.f),
1006                         side_arg_float_binary16(1.1),
1007 # endif
1008 #endif
1009 #if __HAVE_FLOAT32
1010                         side_arg_float_binary32(2.2),
1011 # if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
1012                         side_arg_float_binary32(2.2),
1013                         side_arg_float_binary32(float32.f),
1014 # else
1015                         side_arg_float_binary32(float32.f),
1016                         side_arg_float_binary32(2.2),
1017 # endif
1018 #endif
1019 #if __HAVE_FLOAT64
1020                         side_arg_float_binary64(3.3),
1021 # if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
1022                         side_arg_float_binary64(3.3),
1023                         side_arg_float_binary64(float64.f),
1024 # else
1025                         side_arg_float_binary64(float64.f),
1026                         side_arg_float_binary64(3.3),
1027 # endif
1028 #endif
1029 #if __HAVE_FLOAT128
1030                         side_arg_float_binary128(4.4),
1031 # if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
1032                         side_arg_float_binary128(4.4),
1033                         side_arg_float_binary128(float128.f),
1034 # else
1035                         side_arg_float_binary128(float128.f),
1036                         side_arg_float_binary128(4.4),
1037 # endif
1038 #endif
1039                 )
1040         );
1041 }
1042
1043 side_static_event_variadic(my_provider_event_variadic_float,
1044         "myprovider", "myvariadicfloat", SIDE_LOGLEVEL_DEBUG,
1045         side_field_list(),
1046         side_attr_list()
1047 );
1048
1049 static
1050 void test_variadic_float(void)
1051 {
1052 #if __HAVE_FLOAT16
1053         union {
1054                 _Float16 f;
1055                 uint16_t u;
1056         } float16 = {
1057                 .f = 1.1,
1058         };
1059 #endif
1060 #if __HAVE_FLOAT32
1061         union {
1062                 _Float32 f;
1063                 uint32_t u;
1064         } float32 = {
1065                 .f = 2.2,
1066         };
1067 #endif
1068 #if __HAVE_FLOAT64
1069         union {
1070                 _Float64 f;
1071                 uint64_t u;
1072         } float64 = {
1073                 .f = 3.3,
1074         };
1075 #endif
1076 #if __HAVE_FLOAT128
1077         union {
1078                 _Float128 f;
1079                 char arr[16];
1080         } float128 = {
1081                 .f = 4.4,
1082         };
1083 #endif
1084
1085 #if __HAVE_FLOAT16
1086         float16.u = side_bswap_16(float16.u);
1087 #endif
1088 #if __HAVE_FLOAT32
1089         float32.u = side_bswap_32(float32.u);
1090 #endif
1091 #if __HAVE_FLOAT64
1092         float64.u = side_bswap_64(float64.u);
1093 #endif
1094 #if __HAVE_FLOAT128
1095         side_bswap_128p(float128.arr);
1096 #endif
1097
1098         side_event_variadic(my_provider_event_variadic_float,
1099                 side_arg_list(),
1100                 side_arg_list(
1101 #if __HAVE_FLOAT16
1102                         side_arg_dynamic_field("binary16", side_arg_dynamic_float_binary16(1.1, side_attr_list())),
1103 # if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
1104                         side_arg_dynamic_field("binary16_le", side_arg_dynamic_float_binary16_le(1.1, side_attr_list())),
1105                         side_arg_dynamic_field("binary16_be", side_arg_dynamic_float_binary16_be(float16.f, side_attr_list())),
1106 # else
1107                         side_arg_dynamic_field("binary16_le", side_arg_dynamic_float_binary16_le(float16.f, side_attr_list())),
1108                         side_arg_dynamic_field("binary16_be", side_arg_dynamic_float_binary16_be(1.1, side_attr_list())),
1109 # endif
1110 #endif
1111 #if __HAVE_FLOAT32
1112                         side_arg_dynamic_field("binary32", side_arg_dynamic_float_binary32(2.2, side_attr_list())),
1113 # if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
1114                         side_arg_dynamic_field("binary32_le", side_arg_dynamic_float_binary32_le(2.2, side_attr_list())),
1115                         side_arg_dynamic_field("binary32_be", side_arg_dynamic_float_binary32_be(float32.f, side_attr_list())),
1116 # else
1117                         side_arg_dynamic_field("binary32_le", side_arg_dynamic_float_binary32_le(float32.f, side_attr_list())),
1118                         side_arg_dynamic_field("binary32_be", side_arg_dynamic_float_binary32_be(2.2, side_attr_list())),
1119 # endif
1120 #endif
1121 #if __HAVE_FLOAT64
1122                         side_arg_dynamic_field("binary64", side_arg_dynamic_float_binary64(3.3, side_attr_list())),
1123 # if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
1124                         side_arg_dynamic_field("binary64_le", side_arg_dynamic_float_binary64_le(3.3, side_attr_list())),
1125                         side_arg_dynamic_field("binary64_be", side_arg_dynamic_float_binary64_be(float64.f, side_attr_list())),
1126 # else
1127                         side_arg_dynamic_field("binary64_le", side_arg_dynamic_float_binary64_le(float64.f, side_attr_list())),
1128                         side_arg_dynamic_field("binary64_be", side_arg_dynamic_float_binary64_be(3.3, side_attr_list())),
1129 # endif
1130 #endif
1131 #if __HAVE_FLOAT128
1132                         side_arg_dynamic_field("binary128", side_arg_dynamic_float_binary128(4.4, side_attr_list())),
1133 # if SIDE_FLOAT_WORD_ORDER == SIDE_LITTLE_ENDIAN
1134                         side_arg_dynamic_field("binary128_le", side_arg_dynamic_float_binary128_le(4.4, side_attr_list())),
1135                         side_arg_dynamic_field("binary128_be", side_arg_dynamic_float_binary128_be(float128.f, side_attr_list())),
1136 # else
1137                         side_arg_dynamic_field("binary128_le", side_arg_dynamic_float_binary128_le(float128.f, side_attr_list())),
1138                         side_arg_dynamic_field("binary128_be", side_arg_dynamic_float_binary128_be(4.4, side_attr_list())),
1139 # endif
1140 #endif
1141                 ),
1142                 side_attr_list()
1143         );
1144 }
1145
1146 static side_define_enum(myenum,
1147         side_enum_mapping_list(
1148                 side_enum_mapping_range("one-ten", 1, 10),
1149                 side_enum_mapping_range("100-200", 100, 200),
1150                 side_enum_mapping_value("200", 200),
1151                 side_enum_mapping_value("300", 300),
1152         ),
1153         side_attr_list()
1154 );
1155
1156 side_static_event(my_provider_event_enum, "myprovider", "myeventenum", SIDE_LOGLEVEL_DEBUG,
1157         side_field_list(
1158                 side_field_enum("5", &myenum, side_elem(side_type_u32(side_attr_list()))),
1159                 side_field_enum("400", &myenum, side_elem(side_type_u64(side_attr_list()))),
1160                 side_field_enum("200", &myenum, side_elem(side_type_u8(side_attr_list()))),
1161                 side_field_enum("-100", &myenum, side_elem(side_type_s8(side_attr_list()))),
1162                 side_field_enum("6_be", &myenum, side_elem(side_type_u32_be(side_attr_list()))),
1163                 side_field_enum("6_le", &myenum, side_elem(side_type_u32_le(side_attr_list()))),
1164         ),
1165         side_attr_list()
1166 );
1167
1168 static
1169 void test_enum(void)
1170 {
1171         side_event(my_provider_event_enum,
1172                 side_arg_list(
1173                         side_arg_u32(5),
1174                         side_arg_u64(400),
1175                         side_arg_u8(200),
1176                         side_arg_s8(-100),
1177 #if SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN
1178                         side_arg_u32(side_bswap_32(6)),
1179                         side_arg_u32(6),
1180 #else
1181                         side_arg_u32(side_bswap_32(6)),
1182                         side_arg_u32(6),
1183 #endif
1184                 )
1185         );
1186 }
1187
1188 /* A bitmap enum maps bits to labels. */
1189 static side_define_enum_bitmap(myenum_bitmap,
1190         side_enum_bitmap_mapping_list(
1191                 side_enum_bitmap_mapping_value("0", 0),
1192                 side_enum_bitmap_mapping_range("1-2", 1, 2),
1193                 side_enum_bitmap_mapping_range("2-4", 2, 4),
1194                 side_enum_bitmap_mapping_value("3", 3),
1195                 side_enum_bitmap_mapping_value("30", 30),
1196                 side_enum_bitmap_mapping_value("63", 63),
1197                 side_enum_bitmap_mapping_range("158-160", 158, 160),
1198                 side_enum_bitmap_mapping_value("159", 159),
1199                 side_enum_bitmap_mapping_range("500-700", 500, 700),
1200         ),
1201         side_attr_list()
1202 );
1203
1204 side_static_event(my_provider_event_enum_bitmap, "myprovider", "myeventenumbitmap", SIDE_LOGLEVEL_DEBUG,
1205         side_field_list(
1206                 side_field_enum_bitmap("bit_0", &myenum_bitmap, side_elem(side_type_u32(side_attr_list()))),
1207                 side_field_enum_bitmap("bit_1", &myenum_bitmap, side_elem(side_type_u32(side_attr_list()))),
1208                 side_field_enum_bitmap("bit_2", &myenum_bitmap, side_elem(side_type_u8(side_attr_list()))),
1209                 side_field_enum_bitmap("bit_3", &myenum_bitmap, side_elem(side_type_u8(side_attr_list()))),
1210                 side_field_enum_bitmap("bit_30", &myenum_bitmap, side_elem(side_type_u32(side_attr_list()))),
1211                 side_field_enum_bitmap("bit_31", &myenum_bitmap, side_elem(side_type_u32(side_attr_list()))),
1212                 side_field_enum_bitmap("bit_63", &myenum_bitmap, side_elem(side_type_u64(side_attr_list()))),
1213                 side_field_enum_bitmap("bits_1+63", &myenum_bitmap, side_elem(side_type_u64(side_attr_list()))),
1214                 side_field_enum_bitmap("byte_bit_2", &myenum_bitmap, side_elem(side_type_byte(side_attr_list()))),
1215                 side_field_enum_bitmap("bit_159", &myenum_bitmap,
1216                         side_elem(side_type_array(side_elem(side_type_u32(side_attr_list())), 5, side_attr_list()))),
1217                 side_field_enum_bitmap("bit_159", &myenum_bitmap,
1218                         side_elem(side_type_vla(side_elem(side_type_u32(side_attr_list())), side_attr_list()))),
1219                 side_field_enum_bitmap("bit_2_be", &myenum_bitmap, side_elem(side_type_u32_be(side_attr_list()))),
1220                 side_field_enum_bitmap("bit_2_le", &myenum_bitmap, side_elem(side_type_u32_le(side_attr_list()))),
1221         ),
1222         side_attr_list()
1223 );
1224
1225 static
1226 void test_enum_bitmap(void)
1227 {
1228         side_event_cond(my_provider_event_enum_bitmap) {
1229                 side_arg_define_vec(myarray,
1230                         side_arg_list(
1231                                 side_arg_u32(0),
1232                                 side_arg_u32(0),
1233                                 side_arg_u32(0),
1234                                 side_arg_u32(0),
1235                                 side_arg_u32(0x80000000),       /* bit 159 */
1236                         )
1237                 );
1238                 side_event_call(my_provider_event_enum_bitmap,
1239                         side_arg_list(
1240                                 side_arg_u32(1 << 0),
1241                                 side_arg_u32(1 << 1),
1242                                 side_arg_u8(1 << 2),
1243                                 side_arg_u8(1 << 3),
1244                                 side_arg_u32(1 << 30),
1245                                 side_arg_u32(1 << 31),
1246                                 side_arg_u64(1ULL << 63),
1247                                 side_arg_u64((1ULL << 1) | (1ULL << 63)),
1248                                 side_arg_byte(1 << 2),
1249                                 side_arg_array(&myarray),
1250                                 side_arg_vla(&myarray),
1251 #if SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN
1252                                 side_arg_u32(side_bswap_32(1 << 2)),
1253                                 side_arg_u32(1 << 2),
1254 #else
1255                                 side_arg_u32(0x06000000),
1256                                 side_arg_u32(side_bswap_32(1 << 2)),
1257 #endif
1258                         )
1259                 );
1260         }
1261 }
1262
1263 static uint8_t blob_fixint[] = { 0x55, 0x44, 0x33, 0x22, 0x11 };
1264
1265 side_static_event_variadic(my_provider_event_blob, "myprovider", "myeventblob", SIDE_LOGLEVEL_DEBUG,
1266         side_field_list(
1267                 side_field_byte("blobfield", side_attr_list()),
1268                 side_field_array("arrayblob", side_elem(side_type_byte(side_attr_list())), 3, side_attr_list()),
1269                 side_field_array("arrayblobfix", side_elem(side_type_byte(side_attr_list())), SIDE_ARRAY_SIZE(blob_fixint), side_attr_list()),
1270                 side_field_vla("vlablobfix", side_elem(side_type_byte(side_attr_list())), side_attr_list()),
1271         ),
1272         side_attr_list()
1273 );
1274
1275 static
1276 void test_blob(void)
1277 {
1278         side_event_cond(my_provider_event_blob) {
1279                 side_arg_define_vec(myarray, side_arg_list(side_arg_byte(1), side_arg_byte(2), side_arg_byte(3)));
1280                 side_arg_dynamic_define_vec(myvla,
1281                         side_arg_list(
1282                                 side_arg_dynamic_byte(0x22, side_attr_list()),
1283                                 side_arg_dynamic_byte(0x33, side_attr_list()),
1284                         ),
1285                         side_attr_list()
1286                 );
1287                 side_event_call_variadic(my_provider_event_blob,
1288                         side_arg_list(
1289                                 side_arg_byte(0x55),
1290                                 side_arg_array(&myarray),
1291                                 side_arg_array_byte(blob_fixint),
1292                                 side_arg_vla_byte(blob_fixint, SIDE_ARRAY_SIZE(blob_fixint)),
1293                         ),
1294                         side_arg_list(
1295                                 side_arg_dynamic_field("varblobfield",
1296                                         side_arg_dynamic_byte(0x55, side_attr_list())
1297                                 ),
1298                                 side_arg_dynamic_field("varblobvla", side_arg_dynamic_vla(&myvla)),
1299                         ),
1300                         side_attr_list()
1301                 );
1302         }
1303 }
1304
1305 side_static_event_variadic(my_provider_event_format_string,
1306         "myprovider", "myeventformatstring", SIDE_LOGLEVEL_DEBUG,
1307         side_field_list(
1308                 side_field_string("fmt", side_attr_list()),
1309         ),
1310         side_attr_list(
1311                 side_attr("lang.c.format_string", side_attr_bool(true)),
1312         )
1313 );
1314
1315 static
1316 void test_fmt_string(void)
1317 {
1318         side_event_cond(my_provider_event_format_string) {
1319                 side_arg_dynamic_define_vec(args,
1320                         side_arg_list(
1321                                 side_arg_dynamic_string("blah", side_attr_list()),
1322                                 side_arg_dynamic_s32(123, side_attr_list()),
1323                         ),
1324                         side_attr_list()
1325                 );
1326                 side_event_call_variadic(my_provider_event_format_string,
1327                         side_arg_list(
1328                                 side_arg_string("This is a formatted string with str: %s int: %d"),
1329                         ),
1330                         side_arg_list(
1331                                 side_arg_dynamic_field("arguments", side_arg_dynamic_vla(&args)),
1332                         ),
1333                         side_attr_list()
1334                 );
1335         }
1336 }
1337
1338 side_static_event_variadic(my_provider_event_endian, "myprovider", "myevent_endian", SIDE_LOGLEVEL_DEBUG,
1339         side_field_list(
1340                 side_field_u16_le("u16_le", side_attr_list()),
1341                 side_field_u32_le("u32_le", side_attr_list()),
1342                 side_field_u64_le("u64_le", side_attr_list()),
1343                 side_field_s16_le("s16_le", side_attr_list()),
1344                 side_field_s32_le("s32_le", side_attr_list()),
1345                 side_field_s64_le("s64_le", side_attr_list()),
1346                 side_field_u16_be("u16_be", side_attr_list()),
1347                 side_field_u32_be("u32_be", side_attr_list()),
1348                 side_field_u64_be("u64_be", side_attr_list()),
1349                 side_field_s16_be("s16_be", side_attr_list()),
1350                 side_field_s32_be("s32_be", side_attr_list()),
1351                 side_field_s64_be("s64_be", side_attr_list()),
1352         ),
1353         side_attr_list()
1354 );
1355
1356 static
1357 void test_endian(void)
1358 {
1359         side_event_variadic(my_provider_event_endian,
1360                 side_arg_list(
1361 #if SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN
1362                         side_arg_u16(1),
1363                         side_arg_u32(1),
1364                         side_arg_u64(1),
1365                         side_arg_s16(1),
1366                         side_arg_s32(1),
1367                         side_arg_s64(1),
1368                         side_arg_u16(side_bswap_16(1)),
1369                         side_arg_u32(side_bswap_32(1)),
1370                         side_arg_u64(side_bswap_64(1)),
1371                         side_arg_s16(side_bswap_16(1)),
1372                         side_arg_s32(side_bswap_32(1)),
1373                         side_arg_s64(side_bswap_64(1)),
1374 #else
1375                         side_arg_u16(side_bswap_16(1)),
1376                         side_arg_u32(side_bswap_32(1)),
1377                         side_arg_u64(side_bswap_64(1)),
1378                         side_arg_s16(side_bswap_16(1)),
1379                         side_arg_s32(side_bswap_32(1)),
1380                         side_arg_s64(side_bswap_64(1)),
1381                         side_arg_u16(1),
1382                         side_arg_u32(1),
1383                         side_arg_u64(1),
1384                         side_arg_s16(1),
1385                         side_arg_s32(1),
1386                         side_arg_s64(1),
1387 #endif
1388                 ),
1389                 side_arg_list(
1390 #if SIDE_BYTE_ORDER == SIDE_LITTLE_ENDIAN
1391                         side_arg_dynamic_field("u16_le", side_arg_dynamic_u16_le(1, side_attr_list())),
1392                         side_arg_dynamic_field("u32_le", side_arg_dynamic_u32_le(1, side_attr_list())),
1393                         side_arg_dynamic_field("u64_le", side_arg_dynamic_u64_le(1, side_attr_list())),
1394                         side_arg_dynamic_field("s16_le", side_arg_dynamic_s16_le(1, side_attr_list())),
1395                         side_arg_dynamic_field("s32_le", side_arg_dynamic_s32_le(1, side_attr_list())),
1396                         side_arg_dynamic_field("s64_le", side_arg_dynamic_s64_le(1, side_attr_list())),
1397                         side_arg_dynamic_field("u16_be", side_arg_dynamic_u16_be(side_bswap_16(1), side_attr_list())),
1398                         side_arg_dynamic_field("u32_be", side_arg_dynamic_u32_be(side_bswap_32(1), side_attr_list())),
1399                         side_arg_dynamic_field("u64_be", side_arg_dynamic_u64_be(side_bswap_64(1), side_attr_list())),
1400                         side_arg_dynamic_field("s16_be", side_arg_dynamic_s16_be(side_bswap_16(1), side_attr_list())),
1401                         side_arg_dynamic_field("s32_be", side_arg_dynamic_s32_be(side_bswap_32(1), side_attr_list())),
1402                         side_arg_dynamic_field("s64_be", side_arg_dynamic_s64_be(side_bswap_64(1), side_attr_list())),
1403 #else
1404                         side_arg_dynamic_field("u16_le", side_arg_dynamic_u16_le(side_bswap_16(1), side_attr_list())),
1405                         side_arg_dynamic_field("u32_le", side_arg_dynamic_u32_le(side_bswap_32(1), side_attr_list())),
1406                         side_arg_dynamic_field("u64_le", side_arg_dynamic_u64_le(side_bswap_64(1), side_attr_list())),
1407                         side_arg_dynamic_field("s16_le", side_arg_dynamic_s16_le(side_bswap_16(1), side_attr_list())),
1408                         side_arg_dynamic_field("s32_le", side_arg_dynamic_s32_le(side_bswap_32(1), side_attr_list())),
1409                         side_arg_dynamic_field("s64_le", side_arg_dynamic_s64_le(side_bswap_64(1), side_attr_list())),
1410                         side_arg_dynamic_field("u16_be", side_arg_dynamic_u16_be(1, side_attr_list())),
1411                         side_arg_dynamic_field("u32_be", side_arg_dynamic_u32_be(1, side_attr_list())),
1412                         side_arg_dynamic_field("u64_be", side_arg_dynamic_u64_be(1, side_attr_list())),
1413                         side_arg_dynamic_field("s16_be", side_arg_dynamic_s16_be(1, side_attr_list())),
1414                         side_arg_dynamic_field("s32_be", side_arg_dynamic_s32_be(1, side_attr_list())),
1415                         side_arg_dynamic_field("s64_be", side_arg_dynamic_s64_be(1, side_attr_list())),
1416 #endif
1417                 ),
1418                 side_attr_list()
1419         );
1420 }
1421
1422 side_static_event(my_provider_event_base, "myprovider", "myevent_base", SIDE_LOGLEVEL_DEBUG,
1423         side_field_list(
1424                 side_field_u8("u8base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
1425                 side_field_u8("u8base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
1426                 side_field_u8("u8base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1427                 side_field_u8("u8base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
1428                 side_field_u16("u16base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
1429                 side_field_u16("u16base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
1430                 side_field_u16("u16base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1431                 side_field_u16("u16base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
1432                 side_field_u32("u32base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
1433                 side_field_u32("u32base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
1434                 side_field_u32("u32base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1435                 side_field_u32("u32base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
1436                 side_field_u64("u64base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
1437                 side_field_u64("u64base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
1438                 side_field_u64("u64base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1439                 side_field_u64("u64base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
1440                 side_field_s8("s8base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
1441                 side_field_s8("s8base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
1442                 side_field_s8("s8base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1443                 side_field_s8("s8base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
1444                 side_field_s16("s16base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
1445                 side_field_s16("s16base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
1446                 side_field_s16("s16base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1447                 side_field_s16("s16base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
1448                 side_field_s32("s32base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
1449                 side_field_s32("s32base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
1450                 side_field_s32("s32base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1451                 side_field_s32("s32base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
1452                 side_field_s64("s64base2", side_attr_list(side_attr("std.integer.base", side_attr_u8(2)))),
1453                 side_field_s64("s64base8", side_attr_list(side_attr("std.integer.base", side_attr_u8(8)))),
1454                 side_field_s64("s64base10", side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1455                 side_field_s64("s64base16", side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
1456         ),
1457         side_attr_list()
1458 );
1459
1460 static
1461 void test_base(void)
1462 {
1463         side_event(my_provider_event_base,
1464                 side_arg_list(
1465                         side_arg_u8(55),
1466                         side_arg_u8(55),
1467                         side_arg_u8(55),
1468                         side_arg_u8(55),
1469                         side_arg_u16(55),
1470                         side_arg_u16(55),
1471                         side_arg_u16(55),
1472                         side_arg_u16(55),
1473                         side_arg_u32(55),
1474                         side_arg_u32(55),
1475                         side_arg_u32(55),
1476                         side_arg_u32(55),
1477                         side_arg_u64(55),
1478                         side_arg_u64(55),
1479                         side_arg_u64(55),
1480                         side_arg_u64(55),
1481                         side_arg_s8(-55),
1482                         side_arg_s8(-55),
1483                         side_arg_s8(-55),
1484                         side_arg_s8(-55),
1485                         side_arg_s16(-55),
1486                         side_arg_s16(-55),
1487                         side_arg_s16(-55),
1488                         side_arg_s16(-55),
1489                         side_arg_s32(-55),
1490                         side_arg_s32(-55),
1491                         side_arg_s32(-55),
1492                         side_arg_s32(-55),
1493                         side_arg_s64(-55),
1494                         side_arg_s64(-55),
1495                         side_arg_s64(-55),
1496                         side_arg_s64(-55),
1497                 )
1498         );
1499 }
1500
1501 struct test {
1502         uint32_t a;
1503         uint64_t b;
1504         uint8_t c;
1505         int32_t d;
1506         uint16_t e;
1507         int8_t f;
1508         int16_t g;
1509         int32_t h;
1510         int64_t i;
1511         int64_t j;
1512         int64_t k;
1513 };
1514
1515 static side_define_struct_sg(mystructsgdef,
1516         side_field_sg_list(
1517                 side_field_sg_unsigned_integer("a", offsetof(struct test, a),
1518                         side_struct_field_sizeof_bit(struct test, a), 0,
1519                         side_struct_field_sizeof_bit(struct test, a), side_attr_list()),
1520                 side_field_sg_signed_integer("d", offsetof(struct test, d),
1521                         side_struct_field_sizeof_bit(struct test, d), 0,
1522                         side_struct_field_sizeof_bit(struct test, d), side_attr_list()),
1523                 side_field_sg_unsigned_integer("e", offsetof(struct test, e),
1524                         side_struct_field_sizeof_bit(struct test, e), 8, 4,
1525                         side_attr_list(side_attr("std.integer.base", side_attr_u8(16)))),
1526                 side_field_sg_signed_integer("f", offsetof(struct test, f),
1527                         side_struct_field_sizeof_bit(struct test, f), 1, 4,
1528                         side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1529                 side_field_sg_signed_integer("g", offsetof(struct test, g),
1530                         side_struct_field_sizeof_bit(struct test, g), 11, 4,
1531                         side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1532                 side_field_sg_signed_integer("h", offsetof(struct test, h),
1533                         side_struct_field_sizeof_bit(struct test, h), 1, 31,
1534                         side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1535                 side_field_sg_signed_integer("i", offsetof(struct test, i),
1536                         side_struct_field_sizeof_bit(struct test, i), 33, 20,
1537                         side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1538                 side_field_sg_signed_integer("j", offsetof(struct test, j),
1539                         side_struct_field_sizeof_bit(struct test, j), 63, 1,
1540                         side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1541                 side_field_sg_signed_integer("k", offsetof(struct test, k),
1542                         side_struct_field_sizeof_bit(struct test, k), 1, 63,
1543                         side_attr_list(side_attr("std.integer.base", side_attr_u8(10)))),
1544                 side_field_sg_null("null", side_attr_list()),
1545         ),
1546         side_attr_list()
1547 );
1548
1549 side_static_event(my_provider_event_structsg, "myprovider", "myeventstructsg", SIDE_LOGLEVEL_DEBUG,
1550         side_field_list(
1551                 side_field_struct_sg("structsg", &mystructsgdef),
1552         ),
1553         side_attr_list()
1554 );
1555
1556 static
1557 void test_struct_sg(void)
1558 {
1559         side_event_cond(my_provider_event_structsg) {
1560                 struct test mystruct = {
1561                         .a = 55,
1562                         .b = 123,
1563                         .c = 2,
1564                         .d = -55,
1565                         .e = 0xABCD,
1566                         .f = -1,
1567                         .g = -1,
1568                         .h = -1,
1569                         .i = -1,
1570                         .j = -1,
1571                         .k = -1,
1572                 };
1573                 side_event_call(my_provider_event_structsg, side_arg_list(side_arg_struct_sg(&mystruct)));
1574         }
1575 }
1576
1577 int main()
1578 {
1579         test_fields();
1580         test_event_hidden();
1581         test_event_export();
1582         test_struct_literal();
1583         test_struct();
1584         test_array();
1585         test_vla();
1586         test_vla_visitor();
1587         test_vla_visitor_2d();
1588         test_array_fixint();
1589         test_vla_fixint();
1590         test_dynamic_basic_type();
1591         test_dynamic_vla();
1592         test_dynamic_null();
1593         test_dynamic_struct();
1594         test_dynamic_nested_struct();
1595         test_dynamic_vla_struct();
1596         test_dynamic_struct_vla();
1597         test_dynamic_nested_vla();
1598         test_variadic();
1599         test_static_variadic();
1600         test_bool();
1601         test_dynamic_bool();
1602         test_dynamic_vla_with_visitor();
1603         test_dynamic_struct_with_visitor();
1604         test_event_user_attribute();
1605         test_field_user_attribute();
1606         test_variadic_attr();
1607         test_variadic_vla_attr();
1608         test_variadic_struct_attr();
1609         test_float();
1610         test_variadic_float();
1611         test_enum();
1612         test_enum_bitmap();
1613         test_blob();
1614         test_fmt_string();
1615         test_endian();
1616         test_base();
1617         test_struct_sg();
1618         return 0;
1619 }