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
  11 #include <side/trace.h>
  12 #include "tracer.h"
  13
  14 /* User code example */
  15
  16 static side_define_event(my_provider_event, "myprovider", "myevent", SIDE_LOGLEVEL_DEBUG,
  17         side_field_list(
  18                 side_field("abc", SIDE_TYPE_U32),
  19                 side_field("def", SIDE_TYPE_S64),
  20                 side_field("dynamic", SIDE_TYPE_DYNAMIC),
  21         )
  22 );
  23
  24 static
  25 void test_fields(void)
  26 {
  27         uint32_t uw = 42;
  28         int64_t sdw = -500;
  29
  30         my_provider_event.enabled = 1;
  31         side_event(&my_provider_event, side_arg_list(side_arg_u32(uw), side_arg_s64(sdw),
  32                 side_arg_dynamic(side_arg_dynamic_string("zzz"))));
  33 }
  34
  35 static side_define_event(my_provider_event2, "myprovider", "myevent2", SIDE_LOGLEVEL_DEBUG,
  36         side_field_list(
  37                 side_field_struct("structfield",
  38                         side_field_list(
  39                                 side_field("x", SIDE_TYPE_U32),
  40                                 side_field("y", SIDE_TYPE_S64),
  41                         )
  42                 ),
  43                 side_field("z", SIDE_TYPE_U8),
  44         )
  45 );
  46
  47 static
  48 void test_struct(void)
  49 {
  50         my_provider_event2.enabled = 1;
  51         side_event_cond(&my_provider_event2) {
  52                 side_arg_define_vec(mystruct, side_arg_list(side_arg_u32(21), side_arg_s64(22)));
  53                 side_event_call(&my_provider_event2, side_arg_list(side_arg_struct(&mystruct), side_arg_u8(55)));
  54         }
  55 }
  56
  57 static side_define_event(my_provider_event_array, "myprovider", "myarray", SIDE_LOGLEVEL_DEBUG,
  58         side_field_list(
  59                 side_field_array("arr", side_elem_type(SIDE_TYPE_U32), 3),
  60                 side_field("v", SIDE_TYPE_S64),
  61         )
  62 );
  63
  64 static
  65 void test_array(void)
  66 {
  67         my_provider_event_array.enabled = 1;
  68         side_event_cond(&my_provider_event_array) {
  69                 side_arg_define_vec(myarray, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
  70                 side_event_call(&my_provider_event_array, side_arg_list(side_arg_array(&myarray), side_arg_s64(42)));
  71         }
  72 }
  73
  74 static side_define_event(my_provider_event_vla, "myprovider", "myvla", SIDE_LOGLEVEL_DEBUG,
  75         side_field_list(
  76                 side_field_vla("vla", side_elem_type(SIDE_TYPE_U32)),
  77                 side_field("v", SIDE_TYPE_S64),
  78         )
  79 );
  80
  81 static
  82 void test_vla(void)
  83 {
  84         my_provider_event_vla.enabled = 1;
  85         side_event_cond(&my_provider_event_vla) {
  86                 side_arg_define_vec(myvla, side_arg_list(side_arg_u32(1), side_arg_u32(2), side_arg_u32(3)));
  87                 side_event_call(&my_provider_event_vla, side_arg_list(side_arg_vla(&myvla), side_arg_s64(42)));
  88         }
  89 }
  90
  91 /* 1D array visitor */
  92
  93 struct app_visitor_ctx {
  94         const uint32_t *ptr;
  95         uint32_t length;
  96 };
  97
  98 static
  99 enum side_visitor_status test_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 100 {
 101         struct app_visitor_ctx *ctx = (struct app_visitor_ctx *) _ctx;
 102         uint32_t length = ctx->length, i;
 103
 104         for (i = 0; i < length; i++) {
 105                 const struct side_arg_vec elem = {
 106                         .type = SIDE_TYPE_U32,
 107                         .u = {
 108                                 .side_u32 = ctx->ptr[i],
 109                         },
 110                 };
 111                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 112                         return SIDE_VISITOR_STATUS_ERROR;
 113         }
 114         return SIDE_VISITOR_STATUS_OK;
 115 }
 116
 117 static uint32_t testarray[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 118
 119 static side_define_event(my_provider_event_vla_visitor, "myprovider", "myvlavisit", SIDE_LOGLEVEL_DEBUG,
 120         side_field_list(
 121                 side_field_vla_visitor("vlavisit", side_elem_type(SIDE_TYPE_U32), test_visitor),
 122                 side_field("v", SIDE_TYPE_S64),
 123         )
 124 );
 125
 126 static
 127 void test_vla_visitor(void)
 128 {
 129         my_provider_event_vla_visitor.enabled = 1;
 130         side_event_cond(&my_provider_event_vla_visitor) {
 131                 struct app_visitor_ctx ctx = {
 132                         .ptr = testarray,
 133                         .length = SIDE_ARRAY_SIZE(testarray),
 134                 };
 135                 side_event_call(&my_provider_event_vla_visitor, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
 136         }
 137 }
 138
 139 /* 2D array visitor */
 140
 141 struct app_visitor_2d_inner_ctx {
 142         const uint32_t *ptr;
 143         uint32_t length;
 144 };
 145
 146 static
 147 enum side_visitor_status test_inner_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 148 {
 149         struct app_visitor_2d_inner_ctx *ctx = (struct app_visitor_2d_inner_ctx *) _ctx;
 150         uint32_t length = ctx->length, i;
 151
 152         for (i = 0; i < length; i++) {
 153                 const struct side_arg_vec elem = {
 154                         .type = SIDE_TYPE_U32,
 155                         .u = {
 156                                 .side_u32 = ctx->ptr[i],
 157                         },
 158                 };
 159                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 160                         return SIDE_VISITOR_STATUS_ERROR;
 161         }
 162         return SIDE_VISITOR_STATUS_OK;
 163 }
 164
 165 struct app_visitor_2d_outer_ctx {
 166         const uint32_t (*ptr)[2];
 167         uint32_t length;
 168 };
 169
 170 static
 171 enum side_visitor_status test_outer_visitor(const struct side_tracer_visitor_ctx *tracer_ctx, void *_ctx)
 172 {
 173         struct app_visitor_2d_outer_ctx *ctx = (struct app_visitor_2d_outer_ctx *) _ctx;
 174         uint32_t length = ctx->length, i;
 175
 176         for (i = 0; i < length; i++) {
 177                 struct app_visitor_2d_inner_ctx inner_ctx = {
 178                         .ptr = ctx->ptr[i],
 179                         .length = 2,
 180                 };
 181                 const struct side_arg_vec elem = side_arg_vla_visitor(&inner_ctx);
 182                 if (tracer_ctx->write_elem(tracer_ctx, &elem) != SIDE_VISITOR_STATUS_OK)
 183                         return SIDE_VISITOR_STATUS_ERROR;
 184         }
 185         return SIDE_VISITOR_STATUS_OK;
 186 }
 187
 188 static uint32_t testarray2d[][2] = {
 189         { 1, 2 },
 190         { 33, 44 },
 191         { 55, 66 },
 192 };
 193
 194 static side_define_event(my_provider_event_vla_visitor2d, "myprovider", "myvlavisit2d", SIDE_LOGLEVEL_DEBUG,
 195         side_field_list(
 196                 side_field_vla_visitor("vlavisit2d",
 197                         side_elem(side_type_vla_visitor_decl(side_elem_type(SIDE_TYPE_U32), test_inner_visitor)), test_outer_visitor),
 198                 side_field("v", SIDE_TYPE_S64),
 199         )
 200 );
 201
 202 static
 203 void test_vla_visitor_2d(void)
 204 {
 205         my_provider_event_vla_visitor2d.enabled = 1;
 206         side_event_cond(&my_provider_event_vla_visitor2d) {
 207                 struct app_visitor_2d_outer_ctx ctx = {
 208                         .ptr = testarray2d,
 209                         .length = SIDE_ARRAY_SIZE(testarray2d),
 210                 };
 211                 side_event_call(&my_provider_event_vla_visitor2d, side_arg_list(side_arg_vla_visitor(&ctx), side_arg_s64(42)));
 212         }
 213 }
 214
 215 static int64_t array_fixint[] = { -444, 555, 123, 2897432587 };
 216
 217 static side_define_event(my_provider_event_array_fixint, "myprovider", "myarrayfixint", SIDE_LOGLEVEL_DEBUG,
 218         side_field_list(
 219                 side_field_array("arrfixint", side_elem_type(SIDE_TYPE_S64), SIDE_ARRAY_SIZE(array_fixint)),
 220                 side_field("v", SIDE_TYPE_S64),
 221         )
 222 );
 223
 224 static
 225 void test_array_fixint(void)
 226 {
 227         my_provider_event_array_fixint.enabled = 1;
 228         side_event(&my_provider_event_array_fixint,
 229                 side_arg_list(side_arg_array_s64(array_fixint), side_arg_s64(42)));
 230 }
 231
 232 static int64_t vla_fixint[] = { -444, 555, 123, 2897432587 };
 233
 234 static side_define_event(my_provider_event_vla_fixint, "myprovider", "myvlafixint", SIDE_LOGLEVEL_DEBUG,
 235         side_field_list(
 236                 side_field_vla("vlafixint", side_elem_type(SIDE_TYPE_S64)),
 237                 side_field("v", SIDE_TYPE_S64),
 238         )
 239 );
 240
 241 static
 242 void test_vla_fixint(void)
 243 {
 244         my_provider_event_vla_fixint.enabled = 1;
 245         side_event(&my_provider_event_vla_fixint,
 246                 side_arg_list(side_arg_vla_s64(vla_fixint, SIDE_ARRAY_SIZE(vla_fixint)), side_arg_s64(42)));
 247 }
 248
 249 static side_define_event(my_provider_event_dynamic_basic,
 250         "myprovider", "mydynamicbasic", SIDE_LOGLEVEL_DEBUG,
 251         side_field_list(
 252                 side_field("dynamic", SIDE_TYPE_DYNAMIC),
 253         )
 254 );
 255
 256 static
 257 void test_dynamic_basic_type(void)
 258 {
 259         my_provider_event_dynamic_basic.enabled = 1;
 260         side_event(&my_provider_event_dynamic_basic,
 261                 side_arg_list(side_arg_dynamic(side_arg_dynamic_s16(-33))));
 262 }
 263
 264 static side_define_event(my_provider_event_dynamic_vla,
 265         "myprovider", "mydynamicvla", SIDE_LOGLEVEL_DEBUG,
 266         side_field_list(
 267                 side_field("dynamic", SIDE_TYPE_DYNAMIC),
 268         )
 269 );
 270
 271 static
 272 void test_dynamic_vla(void)
 273 {
 274         side_arg_dynamic_define_vec(myvla,
 275                 side_arg_list(
 276                         side_arg_dynamic_u32(1), side_arg_dynamic_u32(2), side_arg_dynamic_u32(3),
 277                 )
 278         );
 279         my_provider_event_dynamic_vla.enabled = 1;
 280         side_event(&my_provider_event_dynamic_vla,
 281                 side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
 282 }
 283
 284 static side_define_event(my_provider_event_dynamic_null,
 285         "myprovider", "mydynamicnull", SIDE_LOGLEVEL_DEBUG,
 286         side_field_list(
 287                 side_field("dynamic", SIDE_TYPE_DYNAMIC),
 288         )
 289 );
 290
 291 static
 292 void test_dynamic_null(void)
 293 {
 294         my_provider_event_dynamic_null.enabled = 1;
 295         side_event(&my_provider_event_dynamic_null,
 296                 side_arg_list(side_arg_dynamic(side_arg_dynamic_null())));
 297 }
 298
 299 static side_define_event(my_provider_event_dynamic_struct,
 300         "myprovider", "mydynamicstruct", SIDE_LOGLEVEL_DEBUG,
 301         side_field_list(
 302                 side_field("dynamic", SIDE_TYPE_DYNAMIC),
 303         )
 304 );
 305
 306 static
 307 void test_dynamic_struct(void)
 308 {
 309         side_arg_dynamic_define_struct(mystruct,
 310                 side_arg_list(
 311                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
 312                         side_arg_dynamic_field("b", side_arg_dynamic_string("zzz")),
 313                         side_arg_dynamic_field("c", side_arg_dynamic_null()),
 314                 )
 315         );
 316
 317         my_provider_event_dynamic_struct.enabled = 1;
 318         side_event(&my_provider_event_dynamic_struct,
 319                 side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
 320 }
 321
 322 static side_define_event(my_provider_event_dynamic_nested_struct,
 323         "myprovider", "mydynamicnestedstruct", SIDE_LOGLEVEL_DEBUG,
 324         side_field_list(
 325                 side_field("dynamic", SIDE_TYPE_DYNAMIC),
 326         )
 327 );
 328
 329 static
 330 void test_dynamic_nested_struct(void)
 331 {
 332         side_arg_dynamic_define_struct(nested,
 333                 side_arg_list(
 334                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
 335                         side_arg_dynamic_field("b", side_arg_dynamic_u8(55)),
 336                 )
 337         );
 338         side_arg_dynamic_define_struct(nested2,
 339                 side_arg_list(
 340                         side_arg_dynamic_field("aa", side_arg_dynamic_u64(128)),
 341                         side_arg_dynamic_field("bb", side_arg_dynamic_u16(1)),
 342                 )
 343         );
 344         side_arg_dynamic_define_struct(mystruct,
 345                 side_arg_list(
 346                         side_arg_dynamic_field("nested", side_arg_dynamic_struct(&nested)),
 347                         side_arg_dynamic_field("nested2", side_arg_dynamic_struct(&nested2)),
 348                 )
 349         );
 350         my_provider_event_dynamic_nested_struct.enabled = 1;
 351         side_event(&my_provider_event_dynamic_nested_struct,
 352                 side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
 353 }
 354
 355 static side_define_event(my_provider_event_dynamic_vla_struct,
 356         "myprovider", "mydynamicvlastruct", SIDE_LOGLEVEL_DEBUG,
 357         side_field_list(
 358                 side_field("dynamic", SIDE_TYPE_DYNAMIC),
 359         )
 360 );
 361
 362 static
 363 void test_dynamic_vla_struct(void)
 364 {
 365         side_arg_dynamic_define_struct(nested,
 366                 side_arg_list(
 367                         side_arg_dynamic_field("a", side_arg_dynamic_u32(43)),
 368                         side_arg_dynamic_field("b", side_arg_dynamic_u8(55)),
 369                 )
 370         );
 371         side_arg_dynamic_define_vec(myvla,
 372                 side_arg_list(
 373                         side_arg_dynamic_struct(&nested),
 374                         side_arg_dynamic_struct(&nested),
 375                         side_arg_dynamic_struct(&nested),
 376                         side_arg_dynamic_struct(&nested),
 377                 )
 378         );
 379         my_provider_event_dynamic_vla_struct.enabled = 1;
 380         side_event(&my_provider_event_dynamic_vla_struct,
 381                 side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
 382 }
 383
 384 static side_define_event(my_provider_event_dynamic_struct_vla,
 385         "myprovider", "mydynamicstructvla", SIDE_LOGLEVEL_DEBUG,
 386         side_field_list(
 387                 side_field("dynamic", SIDE_TYPE_DYNAMIC),
 388         )
 389 );
 390
 391 static
 392 void test_dynamic_struct_vla(void)
 393 {
 394         side_arg_dynamic_define_vec(myvla,
 395                 side_arg_list(
 396                         side_arg_dynamic_u32(1), side_arg_dynamic_u32(2), side_arg_dynamic_u32(3),
 397                 )
 398         );
 399         side_arg_dynamic_define_vec(myvla2,
 400                 side_arg_list(
 401                         side_arg_dynamic_u32(4), side_arg_dynamic_u64(5), side_arg_dynamic_u32(6),
 402                 )
 403         );
 404         side_arg_dynamic_define_struct(mystruct,
 405                 side_arg_list(
 406                         side_arg_dynamic_field("a", side_arg_dynamic_vla(&myvla)),
 407                         side_arg_dynamic_field("b", side_arg_dynamic_vla(&myvla2)),
 408                 )
 409         );
 410         my_provider_event_dynamic_struct_vla.enabled = 1;
 411         side_event(&my_provider_event_dynamic_struct_vla,
 412                 side_arg_list(side_arg_dynamic(side_arg_dynamic_struct(&mystruct))));
 413 }
 414
 415 static side_define_event(my_provider_event_dynamic_nested_vla,
 416         "myprovider", "mydynamicnestedvla", SIDE_LOGLEVEL_DEBUG,
 417         side_field_list(
 418                 side_field("dynamic", SIDE_TYPE_DYNAMIC),
 419         )
 420 );
 421
 422 static
 423 void test_dynamic_nested_vla(void)
 424 {
 425         side_arg_dynamic_define_vec(nestedvla,
 426                 side_arg_list(
 427                         side_arg_dynamic_u32(1), side_arg_dynamic_u16(2), side_arg_dynamic_u32(3),
 428                 )
 429         );
 430         side_arg_dynamic_define_vec(nestedvla2,
 431                 side_arg_list(
 432                         side_arg_dynamic_u8(4), side_arg_dynamic_u32(5), side_arg_dynamic_u32(6),
 433                 )
 434         );
 435         side_arg_dynamic_define_vec(myvla,
 436                 side_arg_list(
 437                         side_arg_dynamic_vla(&nestedvla),
 438                         side_arg_dynamic_vla(&nestedvla2),
 439                 )
 440         );
 441         my_provider_event_dynamic_nested_vla.enabled = 1;
 442         side_event(&my_provider_event_dynamic_nested_vla,
 443                 side_arg_list(side_arg_dynamic(side_arg_dynamic_vla(&myvla))));
 444 }
 445
 446 static side_define_event(my_provider_event_variadic,
 447         "myprovider", "myvariadicevent", SIDE_LOGLEVEL_DEBUG,
 448         side_field_list()
 449 );
 450
 451 static
 452 void test_variadic(void)
 453 {
 454         my_provider_event_variadic.enabled = 1;
 455         side_event_variadic(&my_provider_event_variadic,
 456                 side_arg_list(),
 457                 side_arg_list(
 458                         side_arg_dynamic_field("a", side_arg_dynamic_u32(55)),
 459                         side_arg_dynamic_field("b", side_arg_dynamic_s8(-4)),
 460                 )
 461         );
 462 }
 463
 464 int main()
 465 {
 466         test_fields();
 467         test_struct();
 468         test_array();
 469         test_vla();
 470         test_vla_visitor();
 471         test_vla_visitor_2d();
 472         test_array_fixint();
 473         test_vla_fixint();
 474         test_dynamic_basic_type();
 475         test_dynamic_vla();
 476         test_dynamic_null();
 477         test_dynamic_struct();
 478         test_dynamic_nested_struct();
 479         test_dynamic_vla_struct();
 480         test_dynamic_struct_vla();
 481         test_dynamic_nested_vla();
 482         test_variadic();
 483         return 0;
 484 }