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