src/test.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright 2022 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  */
   5
   6 #include <stdint.h>
   7 #include <inttypes.h>
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <stdbool.h>
  11
  12 #include <side/trace.h>
  13 #include "tracer.h"
  14
  15 /* User code example */
  16
  17 static side_define_event(my_provider_event, "myprovider", "myevent", SIDE_LOGLEVEL_DEBUG,
  18         side_field_list(
  19                 side_field("abc", SIDE_TYPE_U32, side_attr_list()),
  20                 side_field("def", SIDE_TYPE_S64, side_attr_list()),
  21                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
  22         ),
  23         side_attr_list()
  24 );
  25
  26 static
  27 void test_fields(void)
  28 {
  29         uint32_t uw = 42;
  30         int64_t sdw = -500;
  31
  32         my_provider_event.enabled = 1;
  33         side_event(&my_provider_event, side_arg_list(side_arg_u32(uw), side_arg_s64(sdw),
  34                 side_arg_dynamic(side_arg_dynamic_string("zzz", side_attr_list()))));
  35 }
  36
  37 static side_define_event(my_provider_event2, "myprovider", "myevent2", SIDE_LOGLEVEL_DEBUG,
  38         side_field_list(
  39                 side_field_struct("structfield",
  40                         side_field_list(
  41                                 side_field("x", SIDE_TYPE_U32, side_attr_list()),
  42                                 side_field("y", SIDE_TYPE_S64, side_attr_list()),
  43                         ),
  44                         side_attr_list()
  45                 ),
  46                 side_field("z", SIDE_TYPE_U8, side_attr_list()),
  47         ),
  48         side_attr_list()
  49 );
  50
  51 static
  52 void test_struct(void)
  53 {
  54         my_provider_event2.enabled = 1;
  55         side_event_cond(&my_provider_event2) {
  56                 side_arg_define_vec(mystruct, side_arg_list(side_arg_u32(21), side_arg_s64(22)));
  57                 side_event_call(&my_provider_event2, side_arg_list(side_arg_struct(&mystruct), side_arg_u8(55)));
  58         }
  59 }
  60
  61 static side_define_event(my_provider_event_array, "myprovider", "myarray", SIDE_LOGLEVEL_DEBUG,
  62         side_field_list(
  63                 side_field_array("arr", side_elem_type(SIDE_TYPE_U32, side_attr_list()), 3, side_attr_list()),
  64                 side_field("v", SIDE_TYPE_S64, side_attr_list()),
  65         ),
  66         side_attr_list()
  67 );
  68
  69 static
  70 void test_array(void)
  71 {
  72         my_provider_event_array.enabled = 1;
  73         side_event_cond(&my_provider_event_array) {
  74                 side_arg_define_vec(myarray, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
  75                 side_event_call(&my_provider_event_array, side_arg_list(side_arg_array(&myarray), side_arg_s64(42)));
  76         }
  77 }
  78
  79 static side_define_event(my_provider_event_vla, "myprovider", "myvla", SIDE_LOGLEVEL_DEBUG,
  80         side_field_list(
  81                 side_field_vla("vla", side_elem_type(SIDE_TYPE_U32, side_attr_list()), side_attr_list()),
  82                 side_field("v", SIDE_TYPE_S64, side_attr_list()),
  83         ),
  84         side_attr_list()
  85 );
  86
  87 static
  88 void test_vla(void)
  89 {
  90         my_provider_event_vla.enabled = 1;
  91         side_event_cond(&my_provider_event_vla) {
  92                 side_arg_define_vec(myvla, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
  93                 side_event_call(&my_provider_event_vla, side_arg_list(side_arg_vla(&myvla), side_arg_s64(42)));
  94         }
  95 }
  96
  97 /* 1D array visitor */
  98
  99 struct app_visitor_ctx {
 100         const uint32_t *ptr;
 101         uint32_t length;
 102 };
 103
 104 static
 105 enum side_visitor_status test_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 106 {
 107         struct app_visitor_ctx *ctx = (struct app_visitor_ctx *) _ctx;
 108         uint32_t length = ctx->length, i;
 109
 110         for (i = 0; i < length; i++) {
 111                 const struct side_arg_vec elem = {
 112                         .type = SIDE_TYPE_U32,
 113                         .u = {
 114                                 .side_u32 = ctx->ptr[i],
 115                         },
 116                 };
 117                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 118                         return SIDE_VISITOR_STATUS_ERROR;
 119         }
 120         return SIDE_VISITOR_STATUS_OK;
 121 }
 122
 123 static uint32_t testarray[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 124
 125 static side_define_event(my_provider_event_vla_visitor, "myprovider", "myvlavisit", SIDE_LOGLEVEL_DEBUG,
 126         side_field_list(
 127                 side_field_vla_visitor("vlavisit", side_elem_type(SIDE_TYPE_U32, side_attr_list()), test_visitor, side_attr_list()),
 128                 side_field("v", SIDE_TYPE_S64, side_attr_list()),
 129         ),
 130         side_attr_list()
 131 );
 132
 133 static
 134 void test_vla_visitor(void)
 135 {
 136         my_provider_event_vla_visitor.enabled = 1;
 137         side_event_cond(&my_provider_event_vla_visitor) {
 138                 struct app_visitor_ctx ctx = {
 139                         .ptr = testarray,
 140                         .length = SIDE_ARRAY_SIZE(testarray),
 141                 };
 142                 side_event_call(&my_provider_event_vla_visitor, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
 143         }
 144 }
 145
 146 /* 2D array visitor */
 147
 148 struct app_visitor_2d_inner_ctx {
 149         const uint32_t *ptr;
 150         uint32_t length;
 151 };
 152
 153 static
 154 enum side_visitor_status test_inner_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 155 {
 156         struct app_visitor_2d_inner_ctx *ctx = (struct app_visitor_2d_inner_ctx *) _ctx;
 157         uint32_t length = ctx->length, i;
 158
 159         for (i = 0; i < length; i++) {
 160                 const struct side_arg_vec elem = {
 161                         .type = SIDE_TYPE_U32,
 162                         .u = {
 163                                 .side_u32 = ctx->ptr[i],
 164                         },
 165                 };
 166                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 167                         return SIDE_VISITOR_STATUS_ERROR;
 168         }
 169         return SIDE_VISITOR_STATUS_OK;
 170 }
 171
 172 struct app_visitor_2d_outer_ctx {
 173         const uint32_t (*ptr)[2];
 174         uint32_t length;
 175 };
 176
 177 static
 178 enum side_visitor_status test_outer_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 179 {
 180         struct app_visitor_2d_outer_ctx *ctx = (struct app_visitor_2d_outer_ctx *) _ctx;
 181         uint32_t length = ctx->length, i;
 182
 183         for (i = 0; i < length; i++) {
 184                 struct app_visitor_2d_inner_ctx inner_ctx = {
 185                         .ptr = ctx->ptr[i],
 186                         .length = 2,
 187                 };
 188                 const struct side_arg_vec elem = side_arg_vla_visitor(&inner_ctx);
 189                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 190                         return SIDE_VISITOR_STATUS_ERROR;
 191         }
 192         return SIDE_VISITOR_STATUS_OK;
 193 }
 194
 195 static uint32_t testarray2d[][2] = {
 196         { 1, 2 },
 197         { 33, 44 },
 198         { 55, 66 },
 199 };
 200
 201 static side_define_event(my_provider_event_vla_visitor2d, "myprovider", "myvlavisit2d", SIDE_LOGLEVEL_DEBUG,
 202         side_field_list(
 203                 side_field_vla_visitor("vlavisit2d",
 204                         side_elem(
 205                                 side_type_vla_visitor_decl(
 206                                         side_elem_type(SIDE_TYPE_U32, side_attr_list()),
 207                                         test_inner_visitor,
 208                                         side_attr_list())
 209                         ), test_outer_visitor, side_attr_list()),
 210                 side_field("v", SIDE_TYPE_S64, side_attr_list()),
 211         ),
 212         side_attr_list()
 213 );
 214
 215 static
 216 void test_vla_visitor_2d(void)
 217 {
 218         my_provider_event_vla_visitor2d.enabled = 1;
 219         side_event_cond(&my_provider_event_vla_visitor2d) {
 220                 struct app_visitor_2d_outer_ctx ctx = {
 221                         .ptr = testarray2d,
 222                         .length = SIDE_ARRAY_SIZE(testarray2d),
 223                 };
 224                 side_event_call(&my_provider_event_vla_visitor2d, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
 225         }
 226 }
 227
 228 static int64_t array_fixint[] = { -444, 555, 123, 2897432587 };
 229
 230 static side_define_event(my_provider_event_array_fixint, "myprovider", "myarrayfixint", SIDE_LOGLEVEL_DEBUG,
 231         side_field_list(
 232                 side_field_array("arrfixint", side_elem_type(SIDE_TYPE_S64, side_attr_list()), SIDE_ARRAY_SIZE(array_fixint), side_attr_list()),
 233                 side_field("v", SIDE_TYPE_S64, side_attr_list()),
 234         ),
 235         side_attr_list()
 236 );
 237
 238 static
 239 void test_array_fixint(void)
 240 {
 241         my_provider_event_array_fixint.enabled = 1;
 242         side_event(&my_provider_event_array_fixint,
 243                 side_arg_list(side_arg_array_s64(array_fixint), side_arg_s64(42)));
 244 }
 245
 246 static int64_t vla_fixint[] = { -444, 555, 123, 2897432587 };
 247
 248 static side_define_event(my_provider_event_vla_fixint, "myprovider", "myvlafixint", SIDE_LOGLEVEL_DEBUG,
 249         side_field_list(
 250                 side_field_vla("vlafixint", side_elem_type(SIDE_TYPE_S64, side_attr_list()), side_attr_list()),
 251                 side_field("v", SIDE_TYPE_S64, side_attr_list()),
 252         ),
 253         side_attr_list()
 254 );
 255
 256 static
 257 void test_vla_fixint(void)
 258 {
 259         my_provider_event_vla_fixint.enabled = 1;
 260         side_event(&my_provider_event_vla_fixint,
 261                 side_arg_list(side_arg_vla_s64(vla_fixint, SIDE_ARRAY_SIZE(vla_fixint)), side_arg_s64(42)));
 262 }
 263
 264 static side_define_event(my_provider_event_dynamic_basic,
 265         "myprovider", "mydynamicbasic", SIDE_LOGLEVEL_DEBUG,
 266         side_field_list(
 267                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 268         ),
 269         side_attr_list()
 270 );
 271
 272 static
 273 void test_dynamic_basic_type(void)
 274 {
 275         my_provider_event_dynamic_basic.enabled = 1;
 276         side_event(&my_provider_event_dynamic_basic,
 277                 side_arg_list(side_arg_dynamic(side_arg_dynamic_s16(-33, side_attr_list()))));
 278 }
 279
 280 static side_define_event(my_provider_event_dynamic_vla,
 281         "myprovider", "mydynamicvla", SIDE_LOGLEVEL_DEBUG,
 282         side_field_list(
 283                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 284         ),
 285         side_attr_list()
 286 );
 287
 288 static
 289 void test_dynamic_vla(void)
 290 {
 291         side_arg_dynamic_define_vec(myvla,
 292                 side_arg_list(
 293                         side_arg_dynamic_u32(1, side_attr_list()),
 294                         side_arg_dynamic_u32(2, side_attr_list()),
 295                         side_arg_dynamic_u32(3, side_attr_list()),
 296                 )
 297         );
 298         my_provider_event_dynamic_vla.enabled = 1;
 299         side_event(&my_provider_event_dynamic_vla,
 300                 side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla, side_attr_list()))));
 301 }
 302
 303 static side_define_event(my_provider_event_dynamic_null,
 304         "myprovider", "mydynamicnull", SIDE_LOGLEVEL_DEBUG,
 305         side_field_list(
 306                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 307         ),
 308         side_attr_list()
 309 );
 310
 311 static
 312 void test_dynamic_null(void)
 313 {
 314         my_provider_event_dynamic_null.enabled = 1;
 315         side_event(&my_provider_event_dynamic_null,
 316                 side_arg_list(side_arg_dynamic(side_arg_dynamic_null(side_attr_list()))));
 317 }
 318
 319 static side_define_event(my_provider_event_dynamic_struct,
 320         "myprovider", "mydynamicstruct", SIDE_LOGLEVEL_DEBUG,
 321         side_field_list(
 322                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 323         ),
 324         side_attr_list()
 325 );
 326
 327 static
 328 void test_dynamic_struct(void)
 329 {
 330         side_arg_dynamic_define_struct(mystruct,
 331                 side_arg_list(
 332                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
 333                         side_arg_dynamic_field("b", side_arg_dynamic_string("zzz", side_attr_list())),
 334                         side_arg_dynamic_field("c", side_arg_dynamic_null(side_attr_list())),
 335                 )
 336         );
 337
 338         my_provider_event_dynamic_struct.enabled = 1;
 339         side_event(&my_provider_event_dynamic_struct,
 340                 side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct, side_attr_list()))));
 341 }
 342
 343 static side_define_event(my_provider_event_dynamic_nested_struct,
 344         "myprovider", "mydynamicnestedstruct", SIDE_LOGLEVEL_DEBUG,
 345         side_field_list(
 346                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 347         ),
 348         side_attr_list()
 349 );
 350
 351 static
 352 void test_dynamic_nested_struct(void)
 353 {
 354         side_arg_dynamic_define_struct(nested,
 355                 side_arg_list(
 356                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
 357                         side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
 358                 )
 359         );
 360         side_arg_dynamic_define_struct(nested2,
 361                 side_arg_list(
 362                         side_arg_dynamic_field("aa", side_arg_dynamic_u64(128, side_attr_list())),
 363                         side_arg_dynamic_field("bb", side_arg_dynamic_u16(1, side_attr_list())),
 364                 )
 365         );
 366         side_arg_dynamic_define_struct(mystruct,
 367                 side_arg_list(
 368                         side_arg_dynamic_field("nested", side_arg_dynamic_struct(&nested, side_attr_list())),
 369                         side_arg_dynamic_field("nested2", side_arg_dynamic_struct(&nested2, side_attr_list())),
 370                 )
 371         );
 372         my_provider_event_dynamic_nested_struct.enabled = 1;
 373         side_event(&my_provider_event_dynamic_nested_struct,
 374                 side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct, side_attr_list()))));
 375 }
 376
 377 static side_define_event(my_provider_event_dynamic_vla_struct,
 378         "myprovider", "mydynamicvlastruct", SIDE_LOGLEVEL_DEBUG,
 379         side_field_list(
 380                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 381         ),
 382         side_attr_list()
 383 );
 384
 385 static
 386 void test_dynamic_vla_struct(void)
 387 {
 388         side_arg_dynamic_define_struct(nested,
 389                 side_arg_list(
 390                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43, side_attr_list())),
 391                         side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
 392                 )
 393         );
 394         side_arg_dynamic_define_vec(myvla,
 395                 side_arg_list(
 396                         side_arg_dynamic_struct(&nested, side_attr_list()),
 397                         side_arg_dynamic_struct(&nested, side_attr_list()),
 398                         side_arg_dynamic_struct(&nested, side_attr_list()),
 399                         side_arg_dynamic_struct(&nested, side_attr_list()),
 400                 )
 401         );
 402         my_provider_event_dynamic_vla_struct.enabled = 1;
 403         side_event(&my_provider_event_dynamic_vla_struct,
 404                 side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla, side_attr_list()))));
 405 }
 406
 407 static side_define_event(my_provider_event_dynamic_struct_vla,
 408         "myprovider", "mydynamicstructvla", SIDE_LOGLEVEL_DEBUG,
 409         side_field_list(
 410                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 411         ),
 412         side_attr_list()
 413 );
 414
 415 static
 416 void test_dynamic_struct_vla(void)
 417 {
 418         side_arg_dynamic_define_vec(myvla,
 419                 side_arg_list(
 420                         side_arg_dynamic_u32(1, side_attr_list()),
 421                         side_arg_dynamic_u32(2, side_attr_list()),
 422                         side_arg_dynamic_u32(3, side_attr_list()),
 423                 )
 424         );
 425         side_arg_dynamic_define_vec(myvla2,
 426                 side_arg_list(
 427                         side_arg_dynamic_u32(4, side_attr_list()),
 428                         side_arg_dynamic_u64(5, side_attr_list()),
 429                         side_arg_dynamic_u32(6, side_attr_list()),
 430                 )
 431         );
 432         side_arg_dynamic_define_struct(mystruct,
 433                 side_arg_list(
 434                         side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla, side_attr_list())),
 435                         side_arg_dynamic_field("b", side_arg_dynamic_vla(&myvla2, side_attr_list())),
 436                 )
 437         );
 438         my_provider_event_dynamic_struct_vla.enabled = 1;
 439         side_event(&my_provider_event_dynamic_struct_vla,
 440                 side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct, side_attr_list()))));
 441 }
 442
 443 static side_define_event(my_provider_event_dynamic_nested_vla,
 444         "myprovider", "mydynamicnestedvla", SIDE_LOGLEVEL_DEBUG,
 445         side_field_list(
 446                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 447         ),
 448         side_attr_list()
 449 );
 450
 451 static
 452 void test_dynamic_nested_vla(void)
 453 {
 454         side_arg_dynamic_define_vec(nestedvla,
 455                 side_arg_list(
 456                         side_arg_dynamic_u32(1, side_attr_list()),
 457                         side_arg_dynamic_u16(2, side_attr_list()),
 458                         side_arg_dynamic_u32(3, side_attr_list()),
 459                 )
 460         );
 461         side_arg_dynamic_define_vec(nestedvla2,
 462                 side_arg_list(
 463                         side_arg_dynamic_u8(4, side_attr_list()),
 464                         side_arg_dynamic_u32(5, side_attr_list()),
 465                         side_arg_dynamic_u32(6, side_attr_list()),
 466                 )
 467         );
 468         side_arg_dynamic_define_vec(myvla,
 469                 side_arg_list(
 470                         side_arg_dynamic_vla(&nestedvla, side_attr_list()),
 471                         side_arg_dynamic_vla(&nestedvla2, side_attr_list()),
 472                 )
 473         );
 474         my_provider_event_dynamic_nested_vla.enabled = 1;
 475         side_event(&my_provider_event_dynamic_nested_vla,
 476                 side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla, side_attr_list()))));
 477 }
 478
 479 static side_define_event_variadic(my_provider_event_variadic,
 480         "myprovider", "myvariadicevent", SIDE_LOGLEVEL_DEBUG,
 481         side_field_list(),
 482         side_attr_list()
 483 );
 484
 485 static
 486 void test_variadic(void)
 487 {
 488         my_provider_event_variadic.enabled = 1;
 489         side_event_variadic(&my_provider_event_variadic,
 490                 side_arg_list(),
 491                 side_arg_list(
 492                         side_arg_dynamic_field("a", side_arg_dynamic_u32(55, side_attr_list())),
 493                         side_arg_dynamic_field("b", side_arg_dynamic_s8(-4, side_attr_list())),
 494                 )
 495         );
 496 }
 497
 498 static side_define_event_variadic(my_provider_event_static_variadic,
 499         "myprovider", "mystaticvariadicevent", SIDE_LOGLEVEL_DEBUG,
 500         side_field_list(
 501                 side_field("abc", SIDE_TYPE_U32, side_attr_list()),
 502                 side_field("def", SIDE_TYPE_U16, side_attr_list()),
 503         ),
 504         side_attr_list()
 505 );
 506
 507 static
 508 void test_static_variadic(void)
 509 {
 510         my_provider_event_static_variadic.enabled = 1;
 511         side_event_variadic(&my_provider_event_static_variadic,
 512                 side_arg_list(
 513                         side_arg_u32(1),
 514                         side_arg_u16(2),
 515                 ),
 516                 side_arg_list(
 517                         side_arg_dynamic_field("a", side_arg_dynamic_u32(55, side_attr_list())),
 518                         side_arg_dynamic_field("b", side_arg_dynamic_s8(-4, side_attr_list())),
 519                 )
 520         );
 521 }
 522
 523 static side_define_event(my_provider_event_bool, "myprovider", "myeventbool", SIDE_LOGLEVEL_DEBUG,
 524         side_field_list(
 525                 side_field("a_false", SIDE_TYPE_BOOL, side_attr_list()),
 526                 side_field("b_true", SIDE_TYPE_BOOL, side_attr_list()),
 527                 side_field("c_true", SIDE_TYPE_BOOL, side_attr_list()),
 528                 side_field("d_true", SIDE_TYPE_BOOL, side_attr_list()),
 529                 side_field("e_true", SIDE_TYPE_BOOL, side_attr_list()),
 530                 side_field("f_false", SIDE_TYPE_BOOL, side_attr_list()),
 531                 side_field("g_true", SIDE_TYPE_BOOL, side_attr_list()),
 532         ),
 533         side_attr_list()
 534 );
 535
 536 static
 537 void test_bool(void)
 538 {
 539         uint32_t a = 0;
 540         uint32_t b = 1;
 541         uint64_t c = 0x12345678;
 542         int16_t d = -32768;
 543         bool e = true;
 544         bool f = false;
 545         uint32_t g = 256;
 546
 547         my_provider_event_bool.enabled = 1;
 548         side_event(&my_provider_event_bool,
 549                 side_arg_list(
 550                         side_arg_bool(a),
 551                         side_arg_bool(b),
 552                         side_arg_bool(c),
 553                         side_arg_bool(d),
 554                         side_arg_bool(e),
 555                         side_arg_bool(f),
 556                         side_arg_bool(g),
 557                 )
 558         );
 559 }
 560
 561 static side_define_event_variadic(my_provider_event_dynamic_bool,
 562         "myprovider", "mydynamicbool", SIDE_LOGLEVEL_DEBUG,
 563         side_field_list(),
 564         side_attr_list()
 565 );
 566
 567 static
 568 void test_dynamic_bool(void)
 569 {
 570         my_provider_event_dynamic_bool.enabled = 1;
 571         side_event_variadic(&my_provider_event_dynamic_bool,
 572                 side_arg_list(),
 573                 side_arg_list(
 574                         side_arg_dynamic_field("a_true", side_arg_dynamic_bool(55, side_attr_list())),
 575                         side_arg_dynamic_field("b_true", side_arg_dynamic_bool(-4, side_attr_list())),
 576                         side_arg_dynamic_field("c_false", side_arg_dynamic_bool(0, side_attr_list())),
 577                         side_arg_dynamic_field("d_true", side_arg_dynamic_bool(256, side_attr_list())),
 578                 )
 579         );
 580 }
 581
 582 static side_define_event(my_provider_event_dynamic_vla_visitor,
 583         "myprovider", "mydynamicvlavisitor", SIDE_LOGLEVEL_DEBUG,
 584         side_field_list(
 585                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 586         ),
 587         side_attr_list()
 588 );
 589
 590 struct app_dynamic_vla_visitor_ctx {
 591         const uint32_t *ptr;
 592         uint32_t length;
 593 };
 594
 595 static
 596 enum side_visitor_status test_dynamic_vla_visitor(const struct side_tracer_dynamic_vla_visitor_ctx *tracer_ctx, void *_ctx)
 597 {
 598         struct app_dynamic_vla_visitor_ctx *ctx = (struct app_dynamic_vla_visitor_ctx *) _ctx;
 599         uint32_t length = ctx->length, i;
 600
 601         for (i = 0; i < length; i++) {
 602                 const struct side_arg_dynamic_vec elem = {
 603                         .dynamic_type = SIDE_DYNAMIC_TYPE_U32,
 604                         .nr_attr = 0,
 605                         .attr = NULL,
 606                         .u = {
 607                                 .side_u32 = ctx->ptr[i],
 608                         },
 609                 };
 610                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 611                         return SIDE_VISITOR_STATUS_ERROR;
 612         }
 613         return SIDE_VISITOR_STATUS_OK;
 614 }
 615
 616 static uint32_t testarray_dynamic_vla[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 617
 618 static
 619 void test_dynamic_vla_with_visitor(void)
 620 {
 621         my_provider_event_dynamic_vla_visitor.enabled = 1;
 622         side_event_cond(&my_provider_event_dynamic_vla_visitor) {
 623                 struct app_dynamic_vla_visitor_ctx ctx = {
 624                         .ptr = testarray_dynamic_vla,
 625                         .length = SIDE_ARRAY_SIZE(testarray_dynamic_vla),
 626                 };
 627                 side_event_call(&my_provider_event_dynamic_vla_visitor,
 628                         side_arg_list(
 629                                 side_arg_dynamic(
 630                                         side_arg_dynamic_vla_visitor(test_dynamic_vla_visitor, &ctx, side_attr_list())
 631                                 )
 632                         )
 633                 );
 634         }
 635 }
 636
 637 static side_define_event(my_provider_event_dynamic_struct_visitor,
 638         "myprovider", "mydynamicstructvisitor", SIDE_LOGLEVEL_DEBUG,
 639         side_field_list(
 640                 side_field("dynamic", SIDE_TYPE_DYNAMIC, side_attr_list()),
 641         ),
 642         side_attr_list()
 643 );
 644
 645 struct struct_visitor_pair {
 646         const char *name;
 647         uint32_t value;
 648 };
 649
 650 struct app_dynamic_struct_visitor_ctx {
 651         const struct struct_visitor_pair *ptr;
 652         uint32_t length;
 653 };
 654
 655 static
 656 enum side_visitor_status test_dynamic_struct_visitor(const struct side_tracer_dynamic_struct_visitor_ctx *tracer_ctx, void *_ctx)
 657 {
 658         struct app_dynamic_struct_visitor_ctx *ctx = (struct app_dynamic_struct_visitor_ctx *) _ctx;
 659         uint32_t length = ctx->length, i;
 660
 661         for (i = 0; i < length; i++) {
 662                 struct side_arg_dynamic_event_field dynamic_field = {
 663                         .field_name = ctx->ptr[i].name,
 664                         .elem = {
 665                                 .dynamic_type = SIDE_DYNAMIC_TYPE_U32,
 666                                 .nr_attr = 0,
 667                                 .attr = NULL,
 668                                 .u = {
 669                                         .side_u32 = ctx->ptr[i].value,
 670                                 },
 671                         },
 672                 };
 673                 if (tracer_ctx->write_field(tracer_ctx, &dynamic_field) != SIDE_VISITOR_STATUS_OK)
 674                         return SIDE_VISITOR_STATUS_ERROR;
 675         }
 676         return SIDE_VISITOR_STATUS_OK;
 677 }
 678
 679 static struct struct_visitor_pair testarray_dynamic_struct[] = {
 680         { "a", 1, },
 681         { "b", 2, },
 682         { "c", 3, },
 683         { "d", 4, },
 684 };
 685
 686 static
 687 void test_dynamic_struct_with_visitor(void)
 688 {
 689         my_provider_event_dynamic_struct_visitor.enabled = 1;
 690         side_event_cond(&my_provider_event_dynamic_struct_visitor) {
 691                 struct app_dynamic_struct_visitor_ctx ctx = {
 692                         .ptr = testarray_dynamic_struct,
 693                         .length = SIDE_ARRAY_SIZE(testarray_dynamic_struct),
 694                 };
 695                 side_event_call(&my_provider_event_dynamic_struct_visitor,
 696                         side_arg_list(
 697                                 side_arg_dynamic(
 698                                         side_arg_dynamic_struct_visitor(test_dynamic_struct_visitor, &ctx, side_attr_list())
 699                                 )
 700                         )
 701                 );
 702         }
 703 }
 704
 705 static side_define_event(my_provider_event_user_attribute, "myprovider", "myevent_user_attribute", SIDE_LOGLEVEL_DEBUG,
 706         side_field_list(
 707                 side_field("abc", SIDE_TYPE_U32, side_attr_list()),
 708                 side_field("def", SIDE_TYPE_S64, side_attr_list()),
 709         ),
 710         side_attr_list(
 711                 side_attr("user_attribute_a", side_attr_string("val1")),
 712                 side_attr("user_attribute_b", side_attr_string("val2")),
 713         )
 714 );
 715
 716 static
 717 void test_event_user_attribute(void)
 718 {
 719         my_provider_event_user_attribute.enabled = 1;
 720         side_event(&my_provider_event_user_attribute, side_arg_list(side_arg_u32(1), side_arg_s64(2)));
 721 }
 722
 723 static side_define_event(my_provider_field_user_attribute, "myprovider", "myevent_field_attribute", SIDE_LOGLEVEL_DEBUG,
 724         side_field_list(
 725                 side_field("abc", SIDE_TYPE_U32,
 726                         side_attr_list(
 727                                 side_attr("user_attribute_a", side_attr_string("val1")),
 728                                 side_attr("user_attribute_b", side_attr_u32(2)),
 729                         )
 730                 ),
 731                 side_field("def", SIDE_TYPE_S64,
 732                         side_attr_list(
 733                                 side_attr("user_attribute_c", side_attr_string("val3")),
 734                                 side_attr("user_attribute_d", side_attr_s64(-5)),
 735                         )
 736                 ),
 737         ),
 738         side_attr_list()
 739 );
 740
 741 static
 742 void test_field_user_attribute(void)
 743 {
 744         my_provider_field_user_attribute.enabled = 1;
 745         side_event(&my_provider_field_user_attribute, side_arg_list(side_arg_u32(1), side_arg_s64(2)));
 746 }
 747
 748 static side_define_event_variadic(my_provider_event_variadic_attr,
 749         "myprovider", "myvariadiceventattr", SIDE_LOGLEVEL_DEBUG,
 750         side_field_list(),
 751         side_attr_list()
 752 );
 753
 754 static
 755 void test_variadic_attr(void)
 756 {
 757         my_provider_event_variadic_attr.enabled = 1;
 758         side_event_variadic(&my_provider_event_variadic_attr,
 759                 side_arg_list(),
 760                 side_arg_list(
 761                         side_arg_dynamic_field("a",
 762                                 side_arg_dynamic_u32(55,
 763                                         side_attr_list(
 764                                                 side_attr("user_attribute_c", side_attr_string("valX")),
 765                                                 side_attr("user_attribute_d", side_attr_u8(55)),
 766                                         )
 767                                 )
 768                         ),
 769                         side_arg_dynamic_field("b",
 770                                 side_arg_dynamic_s8(-4,
 771                                         side_attr_list(
 772                                                 side_attr("X", side_attr_u8(1)),
 773                                                 side_attr("Y", side_attr_s8(2)),
 774                                         )
 775                                 )
 776                         ),
 777                 )
 778         );
 779 }
 780
 781 static side_define_event_variadic(my_provider_event_variadic_vla_attr,
 782         "myprovider", "myvariadiceventvlaattr", SIDE_LOGLEVEL_DEBUG,
 783         side_field_list(),
 784         side_attr_list()
 785 );
 786
 787 static
 788 void test_variadic_vla_attr(void)
 789 {
 790         side_arg_dynamic_define_vec(myvla,
 791                 side_arg_list(
 792                         side_arg_dynamic_u32(1,
 793                                 side_attr_list(
 794                                         side_attr("Z", side_attr_u8(0)),
 795                                         side_attr("A", side_attr_u8(123)),
 796                                 )
 797                         ),
 798                         side_arg_dynamic_u32(2, side_attr_list()),
 799                         side_arg_dynamic_u32(3, side_attr_list()),
 800                 )
 801         );
 802         my_provider_event_variadic_vla_attr.enabled = 1;
 803         side_event_variadic(&my_provider_event_variadic_vla_attr,
 804                 side_arg_list(),
 805                 side_arg_list(
 806                         side_arg_dynamic_field("a",
 807                                 side_arg_dynamic_vla(&myvla,
 808                                         side_attr_list(
 809                                                 side_attr("X", side_attr_u8(1)),
 810                                                 side_attr("Y", side_attr_u8(2)),
 811                                         )
 812                                 )
 813                         ),
 814                 )
 815         );
 816 }
 817
 818 static side_define_event_variadic(my_provider_event_variadic_struct_attr,
 819         "myprovider", "myvariadiceventstructattr", SIDE_LOGLEVEL_DEBUG,
 820         side_field_list(),
 821         side_attr_list()
 822 );
 823
 824 static
 825 void test_variadic_struct_attr(void)
 826 {
 827         my_provider_event_variadic_struct_attr.enabled = 1;
 828         side_event_cond(&my_provider_event_variadic_struct_attr) {
 829                 side_arg_dynamic_define_struct(mystruct,
 830                         side_arg_list(
 831                                 side_arg_dynamic_field("a",
 832                                         side_arg_dynamic_u32(43,
 833                                                 side_attr_list(
 834                                                         side_attr("A", side_attr_bool(true)),
 835                                                 )
 836                                         )
 837                                 ),
 838                                 side_arg_dynamic_field("b", side_arg_dynamic_u8(55, side_attr_list())),
 839                         )
 840                 );
 841                 side_event_call_variadic(&my_provider_event_variadic_struct_attr,
 842                         side_arg_list(),
 843                         side_arg_list(
 844                                 side_arg_dynamic_field("a",
 845                                         side_arg_dynamic_struct(&mystruct,
 846                                                 side_attr_list(
 847                                                         side_attr("X", side_attr_u8(1)),
 848                                                         side_attr("Y", side_attr_u8(2)),
 849                                                 )
 850                                         )
 851                                 ),
 852                         )
 853                 );
 854         }
 855 }
 856
 857 static side_define_event(my_provider_event_float, "myprovider", "myeventfloat", SIDE_LOGLEVEL_DEBUG,
 858         side_field_list(
 859 #if __HAVE_FLOAT16
 860                 side_field("binary16", SIDE_TYPE_FLOAT_BINARY16, side_attr_list()),
 861 #endif
 862 #if __HAVE_FLOAT32
 863                 side_field("binary32", SIDE_TYPE_FLOAT_BINARY32, side_attr_list()),
 864 #endif
 865 #if __HAVE_FLOAT64
 866                 side_field("binary64", SIDE_TYPE_FLOAT_BINARY64, side_attr_list()),
 867 #endif
 868 #if __HAVE_FLOAT128
 869                 side_field("binary128", SIDE_TYPE_FLOAT_BINARY128, side_attr_list()),
 870 #endif
 871         ),
 872         side_attr_list()
 873 );
 874
 875 static
 876 void test_float(void)
 877 {
 878         my_provider_event_float.enabled = 1;
 879         side_event(&my_provider_event_float,
 880                 side_arg_list(
 881 #if __HAVE_FLOAT16
 882                         side_arg_float_binary16(1.1),
 883 #endif
 884 #if __HAVE_FLOAT32
 885                         side_arg_float_binary32(2.2),
 886 #endif
 887 #if __HAVE_FLOAT64
 888                         side_arg_float_binary64(3.3),
 889 #endif
 890 #if __HAVE_FLOAT128
 891                         side_arg_float_binary128(4.4),
 892 #endif
 893                 )
 894         );
 895 }
 896
 897 static side_define_event_variadic(my_provider_event_variadic_float,
 898         "myprovider", "myvariadicfloat", SIDE_LOGLEVEL_DEBUG,
 899         side_field_list(),
 900         side_attr_list()
 901 );
 902
 903 static
 904 void test_variadic_float(void)
 905 {
 906         my_provider_event_variadic_float.enabled = 1;
 907         side_event_variadic(&my_provider_event_variadic_float,
 908                 side_arg_list(),
 909                 side_arg_list(
 910 #if __HAVE_FLOAT16
 911                         side_arg_dynamic_field("binary16",
 912                                 side_arg_dynamic_float_binary16(1.1, side_attr_list())
 913                         ),
 914 #endif
 915 #if __HAVE_FLOAT32
 916                         side_arg_dynamic_field("binary32",
 917                                 side_arg_dynamic_float_binary32(2.2, side_attr_list())
 918                         ),
 919 #endif
 920 #if __HAVE_FLOAT64
 921                         side_arg_dynamic_field("binary64",
 922                                 side_arg_dynamic_float_binary64(3.3, side_attr_list())
 923                         ),
 924 #endif
 925 #if __HAVE_FLOAT128
 926                         side_arg_dynamic_field("binary128",
 927                                 side_arg_dynamic_float_binary128(4.4, side_attr_list())
 928                         ),
 929 #endif
 930                 )
 931         );
 932 }
 933
 934 static side_define_enum(myenum,
 935         side_mapping_list(
 936                 side_enum_mapping_range("one-ten", 1, 10),
 937                 side_enum_mapping_range("100-200", 100, 200),
 938                 side_enum_mapping_value("200", 200),
 939                 side_enum_mapping_value("300", 300),
 940         )
 941 );
 942
 943 static side_define_event(my_provider_event_enum, "myprovider", "myeventenum", SIDE_LOGLEVEL_DEBUG,
 944         side_field_list(
 945                 side_field_enum("5", SIDE_TYPE_ENUM_U32, &myenum, side_attr_list()),
 946                 side_field_enum("400", SIDE_TYPE_ENUM_U64, &myenum, side_attr_list()),
 947                 side_field_enum("200", SIDE_TYPE_ENUM_U8, &myenum, side_attr_list()),
 948                 side_field_enum("-100", SIDE_TYPE_ENUM_S8, &myenum, side_attr_list()),
 949         ),
 950         side_attr_list()
 951 );
 952
 953 static
 954 void test_enum(void)
 955 {
 956         my_provider_event_enum.enabled = 1;
 957         side_event(&my_provider_event_enum,
 958                 side_arg_list(
 959                         side_arg_enum_u32(5),
 960                         side_arg_enum_u64(400),
 961                         side_arg_enum_u8(200),
 962                         side_arg_enum_s8(-100),
 963                 )
 964         );
 965 }
 966
 967 /* A bitmap enum maps bits to labels. */
 968 static side_define_enum(myenum_bitmap,
 969         side_mapping_list(
 970                 side_enum_mapping_value("0", 0),
 971                 side_enum_mapping_range("1-2", 1, 2),
 972                 side_enum_mapping_range("2-4", 2, 4),
 973                 side_enum_mapping_value("3", 3),
 974                 side_enum_mapping_value("30", 30),
 975                 side_enum_mapping_value("63", 63),
 976         )
 977 );
 978
 979 static side_define_event(my_provider_event_enum_bitmap, "myprovider", "myeventenumbitmap", SIDE_LOGLEVEL_DEBUG,
 980         side_field_list(
 981                 side_field_enum("bit_0", SIDE_TYPE_ENUM_BITMAP32, &myenum_bitmap, side_attr_list()),
 982                 side_field_enum("bit_1", SIDE_TYPE_ENUM_BITMAP32, &myenum_bitmap, side_attr_list()),
 983                 side_field_enum("bit_2", SIDE_TYPE_ENUM_BITMAP8, &myenum_bitmap, side_attr_list()),
 984                 side_field_enum("bit_3", SIDE_TYPE_ENUM_BITMAP8, &myenum_bitmap, side_attr_list()),
 985                 side_field_enum("bit_30", SIDE_TYPE_ENUM_BITMAP32, &myenum_bitmap, side_attr_list()),
 986                 side_field_enum("bit_31", SIDE_TYPE_ENUM_BITMAP32, &myenum_bitmap, side_attr_list()),
 987                 side_field_enum("bit_63", SIDE_TYPE_ENUM_BITMAP64, &myenum_bitmap, side_attr_list()),
 988                 side_field_enum("bits_1+63", SIDE_TYPE_ENUM_BITMAP64, &myenum_bitmap, side_attr_list()),
 989         ),
 990         side_attr_list()
 991 );
 992
 993 static
 994 void test_enum_bitmap(void)
 995 {
 996         my_provider_event_enum_bitmap.enabled = 1;
 997         side_event(&my_provider_event_enum_bitmap,
 998                 side_arg_list(
 999                         side_arg_enum_bitmap32(1 << 0),
1000                         side_arg_enum_bitmap32(1 << 1),
1001                         side_arg_enum_bitmap8(1 << 2),
1002                         side_arg_enum_bitmap8(1 << 3),
1003                         side_arg_enum_bitmap32(1 << 30),
1004                         side_arg_enum_bitmap32(1 << 31),
1005                         side_arg_enum_bitmap64(1ULL << 63),
1006                         side_arg_enum_bitmap64((1ULL << 1) | (1ULL << 63)),
1007                 )
1008         );
1009 }
1010
1011
1012 int main()
1013 {
1014         test_fields();
1015         test_struct();
1016         test_array();
1017         test_vla();
1018         test_vla_visitor();
1019         test_vla_visitor_2d();
1020         test_array_fixint();
1021         test_vla_fixint();
1022         test_dynamic_basic_type();
1023         test_dynamic_vla();
1024         test_dynamic_null();
1025         test_dynamic_struct();
1026         test_dynamic_nested_struct();
1027         test_dynamic_vla_struct();
1028         test_dynamic_struct_vla();
1029         test_dynamic_nested_vla();
1030         test_variadic();
1031         test_static_variadic();
1032         test_bool();
1033         test_dynamic_bool();
1034         test_dynamic_vla_with_visitor();
1035         test_dynamic_struct_with_visitor();
1036         test_event_user_attribute();
1037         test_field_user_attribute();
1038         test_variadic_attr();
1039         test_variadic_vla_attr();
1040         test_variadic_struct_attr();
1041         test_float();
1042         test_variadic_float();
1043         test_enum();
1044         test_enum_bitmap();
1045         return 0;
1046 }