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