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