tests/unit/test_action.cpp

   1 /*
   2  * test_action.c
   3  *
   4  * Unit tests for the notification API.
   5  *
   6  * Copyright (C) 2017 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
   7  *
   8  * SPDX-License-Identifier: MIT
   9  *
  10  */
  11
  12 #include <common/payload-view.hpp>
  13 #include <common/payload.hpp>
  14
  15 #include <lttng/action/action-internal.hpp>
  16 #include <lttng/action/action.h>
  17 #include <lttng/action/list-internal.hpp>
  18 #include <lttng/action/notify.h>
  19 #include <lttng/action/rate-policy-internal.hpp>
  20 #include <lttng/action/rate-policy.h>
  21 #include <lttng/action/rotate-session.h>
  22 #include <lttng/action/snapshot-session.h>
  23 #include <lttng/action/start-session.h>
  24 #include <lttng/action/stop-session.h>
  25
  26 #include <inttypes.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <tap/tap.h>
  30 #include <unistd.h>
  31
  32 /* For error.h */
  33 int lttng_opt_quiet = 1;
  34 int lttng_opt_verbose;
  35 int lttng_opt_mi;
  36
  37 #define NUM_TESTS 71
  38
  39 static void test_action_notify()
  40 {
  41         int ret;
  42         enum lttng_action_status status;
  43         struct lttng_action *notify_action = nullptr, *notify_action_from_buffer = nullptr;
  44         struct lttng_rate_policy *policy = nullptr, *default_policy;
  45         struct lttng_payload payload;
  46
  47         lttng_payload_init(&payload);
  48
  49         /* To set. */
  50         policy = lttng_rate_policy_every_n_create(100);
  51         /* For comparison. */
  52         default_policy = lttng_rate_policy_every_n_create(1);
  53
  54         LTTNG_ASSERT(policy && default_policy);
  55
  56         notify_action = lttng_action_notify_create();
  57         ok(notify_action, "Create notify action");
  58         ok(lttng_action_get_type(notify_action) == LTTNG_ACTION_TYPE_NOTIFY,
  59            "Action has type LTTNG_ACTION_TYPE_NOTIFY");
  60
  61         /* Validate the default policy for a notify action. */
  62         {
  63                 const struct lttng_rate_policy *cur_policy = nullptr;
  64                 status = lttng_action_notify_get_rate_policy(notify_action, &cur_policy);
  65                 ok(status == LTTNG_ACTION_STATUS_OK &&
  66                            lttng_rate_policy_is_equal(default_policy, cur_policy),
  67                    "Default policy is every n=1");
  68         }
  69
  70         /* Set a custom policy. */
  71         status = lttng_action_notify_set_rate_policy(notify_action, policy);
  72         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
  73
  74         /* Validate the custom policy for a notify action. */
  75         {
  76                 const struct lttng_rate_policy *cur_policy = nullptr;
  77                 status = lttng_action_notify_get_rate_policy(notify_action, &cur_policy);
  78                 ok(status == LTTNG_ACTION_STATUS_OK &&
  79                            lttng_rate_policy_is_equal(policy, cur_policy),
  80                    "Notify action policy get");
  81         }
  82
  83         ret = lttng_action_serialize(notify_action, &payload);
  84         ok(ret == 0, "Action notify serialized");
  85
  86         {
  87                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
  88                 (void) lttng_action_create_from_payload(&view, &notify_action_from_buffer);
  89         }
  90         ok(notify_action_from_buffer, "Notify action created from payload is non-null");
  91
  92         ok(lttng_action_is_equal(notify_action, notify_action_from_buffer),
  93            "Serialized and de-serialized notify action are equal");
  94
  95         lttng_rate_policy_destroy(default_policy);
  96         lttng_rate_policy_destroy(policy);
  97         lttng_action_destroy(notify_action);
  98         lttng_action_destroy(notify_action_from_buffer);
  99         lttng_payload_reset(&payload);
 100 }
 101
 102 static void test_action_list(void)
 103 {
 104         int ret, action_idx;
 105         struct lttng_action *list_action = NULL, *list_action_from_buffer = NULL,
 106                             *stop_session_action = NULL, *notify_action = NULL,
 107                             *start_session_action = NULL;
 108         struct lttng_payload payload;
 109
 110         lttng_payload_init(&payload);
 111
 112         list_action = lttng_action_list_create();
 113         ok(list_action, "Create list action");
 114         ok(lttng_action_get_type(list_action) == LTTNG_ACTION_TYPE_LIST,
 115            "Action has type LTTNG_ACTION_TYPE_LIST");
 116
 117         start_session_action = lttng_action_start_session_create();
 118         (void) lttng_action_start_session_set_session_name(start_session_action, "une-session");
 119
 120         stop_session_action = lttng_action_stop_session_create();
 121         (void) lttng_action_stop_session_set_session_name(stop_session_action, "une-autre-session");
 122         notify_action = lttng_action_notify_create();
 123
 124         lttng_action_list_add_action(list_action, start_session_action);
 125         lttng_action_list_add_action(list_action, stop_session_action);
 126         lttng_action_list_add_action(list_action, notify_action);
 127
 128         ret = lttng_action_serialize(list_action, &payload);
 129         ok(ret == 0, "Action list serialized");
 130
 131         {
 132                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 133                 (void) lttng_action_create_from_payload(&view, &list_action_from_buffer);
 134         }
 135         ok(list_action_from_buffer, "Notify action created from payload is non-null");
 136
 137         ok(lttng_action_is_equal(list_action, list_action_from_buffer),
 138            "Serialized and de-serialized list action are equal");
 139
 140         action_idx = 0;
 141         for (auto action : lttng::ctl::const_action_list_view(list_action)) {
 142                 enum lttng_action_type inner_action_type = lttng_action_get_type(action);
 143                 switch (action_idx) {
 144                 case 0:
 145                         ok(inner_action_type == LTTNG_ACTION_TYPE_START_SESSION,
 146                            "First inner action of action list is `start-session` action");
 147                         break;
 148                 case 1:
 149                         ok(inner_action_type == LTTNG_ACTION_TYPE_STOP_SESSION,
 150                            "Second inner action of action list is `stop-session` action");
 151                         break;
 152                 case 2:
 153                         ok(inner_action_type == LTTNG_ACTION_TYPE_NOTIFY,
 154                            "Third inner action of action list is `notify` action");
 155                         break;
 156                 }
 157                 action_idx++;
 158         }
 159
 160         action_idx = 0;
 161         for (auto action : lttng::ctl::action_list_view(list_action)) {
 162                 enum lttng_action_type inner_action_type = lttng_action_get_type(action);
 163                 switch (action_idx) {
 164                 case 0:
 165                         ok(inner_action_type == LTTNG_ACTION_TYPE_START_SESSION,
 166                            "First inner action of action list is `start-session` action");
 167                         break;
 168                 case 1:
 169                         ok(inner_action_type == LTTNG_ACTION_TYPE_STOP_SESSION,
 170                            "Second inner action of action list is `stop-session` action");
 171                         break;
 172                 case 2:
 173                         ok(inner_action_type == LTTNG_ACTION_TYPE_NOTIFY,
 174                            "Third inner action of action list is `notify` action");
 175                         break;
 176                 }
 177                 action_idx++;
 178         }
 179
 180         lttng_action_destroy(list_action);
 181         lttng_action_destroy(list_action_from_buffer);
 182         lttng_action_destroy(start_session_action);
 183         lttng_action_destroy(stop_session_action);
 184         lttng_action_destroy(notify_action);
 185         lttng_payload_reset(&payload);
 186 }
 187
 188 static void test_action_rotate_session(void)
 189 {
 190         int ret;
 191         enum lttng_action_status status;
 192         struct lttng_action *rotate_session_action = nullptr,
 193                             *rotate_session_action_from_buffer = nullptr;
 194         struct lttng_rate_policy *policy = nullptr, *default_policy;
 195         struct lttng_payload payload;
 196         const char *session_name = "my_session_name";
 197         const char *get_session_name;
 198
 199         lttng_payload_init(&payload);
 200
 201         /* To set. */
 202         policy = lttng_rate_policy_every_n_create(100);
 203         /* For comparison. */
 204         default_policy = lttng_rate_policy_every_n_create(1);
 205
 206         LTTNG_ASSERT(policy && default_policy);
 207
 208         rotate_session_action = lttng_action_rotate_session_create();
 209         ok(rotate_session_action, "Create rotate_session action");
 210         ok(lttng_action_get_type(rotate_session_action) == LTTNG_ACTION_TYPE_ROTATE_SESSION,
 211            "Action has type LTTNG_ACTION_TYPE_ROTATE_SESSION");
 212
 213         /* Session name setter. */
 214         status = lttng_action_rotate_session_set_session_name(nullptr, nullptr);
 215         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 216         status = lttng_action_rotate_session_set_session_name(rotate_session_action, nullptr);
 217         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 218         status = lttng_action_rotate_session_set_session_name(nullptr, session_name);
 219         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 220
 221         /* Set the session name */
 222         status = lttng_action_rotate_session_set_session_name(rotate_session_action, session_name);
 223         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 224
 225         status = lttng_action_rotate_session_get_session_name(rotate_session_action,
 226                                                               &get_session_name);
 227         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 228            "Get session name, expected `%s` got `%s`",
 229            session_name,
 230            get_session_name);
 231
 232         /* Validate the default policy for a rotate_session action. */
 233         {
 234                 const struct lttng_rate_policy *cur_policy = nullptr;
 235                 status = lttng_action_rotate_session_get_rate_policy(rotate_session_action,
 236                                                                      &cur_policy);
 237                 ok(status == LTTNG_ACTION_STATUS_OK &&
 238                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 239                    "Default policy is every n=1");
 240         }
 241
 242         /* Set a custom policy. */
 243         status = lttng_action_rotate_session_set_rate_policy(rotate_session_action, policy);
 244         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 245
 246         /* Validate the custom policy for a rotate_session action. */
 247         {
 248                 const struct lttng_rate_policy *cur_policy = nullptr;
 249                 status = lttng_action_rotate_session_get_rate_policy(rotate_session_action,
 250                                                                      &cur_policy);
 251                 ok(status == LTTNG_ACTION_STATUS_OK &&
 252                            lttng_rate_policy_is_equal(policy, cur_policy),
 253                    "rotate_session action policy get");
 254         }
 255
 256         /* Ser/des tests. */
 257         ret = lttng_action_serialize(rotate_session_action, &payload);
 258         ok(ret == 0, "Action rotate_session serialized");
 259
 260         {
 261                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 262                 (void) lttng_action_create_from_payload(&view, &rotate_session_action_from_buffer);
 263         }
 264         ok(rotate_session_action_from_buffer,
 265            "rotate_session action created from payload is non-null");
 266
 267         ok(lttng_action_is_equal(rotate_session_action, rotate_session_action_from_buffer),
 268            "Serialized and de-serialized rotate_session action are equal");
 269
 270         lttng_rate_policy_destroy(default_policy);
 271         lttng_rate_policy_destroy(policy);
 272         lttng_action_destroy(rotate_session_action);
 273         lttng_action_destroy(rotate_session_action_from_buffer);
 274         lttng_payload_reset(&payload);
 275 }
 276
 277 static void test_action_start_session()
 278 {
 279         int ret;
 280         enum lttng_action_status status;
 281         struct lttng_action *start_session_action = nullptr,
 282                             *start_session_action_from_buffer = nullptr;
 283         struct lttng_rate_policy *policy = nullptr, *default_policy;
 284         struct lttng_payload payload;
 285         const char *session_name = "my_session_name";
 286         const char *get_session_name;
 287
 288         lttng_payload_init(&payload);
 289
 290         /* To set. */
 291         policy = lttng_rate_policy_every_n_create(100);
 292         /* For comparison. */
 293         default_policy = lttng_rate_policy_every_n_create(1);
 294
 295         LTTNG_ASSERT(policy && default_policy);
 296
 297         start_session_action = lttng_action_start_session_create();
 298         ok(start_session_action, "Create start_session action");
 299         ok(lttng_action_get_type(start_session_action) == LTTNG_ACTION_TYPE_START_SESSION,
 300            "Action has type LTTNG_ACTION_TYPE_START_SESSION");
 301
 302         /* Session name setter. */
 303         status = lttng_action_start_session_set_session_name(nullptr, nullptr);
 304         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 305         status = lttng_action_start_session_set_session_name(start_session_action, nullptr);
 306         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 307         status = lttng_action_start_session_set_session_name(nullptr, session_name);
 308         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 309
 310         /* Set the session name */
 311         status = lttng_action_start_session_set_session_name(start_session_action, session_name);
 312         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 313
 314         status = lttng_action_start_session_get_session_name(start_session_action,
 315                                                              &get_session_name);
 316         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 317            "Get session name, expected `%s` got `%s`",
 318            session_name,
 319            get_session_name);
 320
 321         /* Validate the default policy for a start_session action. */
 322         {
 323                 const struct lttng_rate_policy *cur_policy = nullptr;
 324                 status = lttng_action_start_session_get_rate_policy(start_session_action,
 325                                                                     &cur_policy);
 326                 ok(status == LTTNG_ACTION_STATUS_OK &&
 327                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 328                    "Default policy is every n=1");
 329         }
 330
 331         /* Set a custom policy. */
 332         status = lttng_action_start_session_set_rate_policy(start_session_action, policy);
 333         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 334
 335         /* Validate the custom policy for a start_session action. */
 336         {
 337                 const struct lttng_rate_policy *cur_policy = nullptr;
 338                 status = lttng_action_start_session_get_rate_policy(start_session_action,
 339                                                                     &cur_policy);
 340                 ok(status == LTTNG_ACTION_STATUS_OK &&
 341                            lttng_rate_policy_is_equal(policy, cur_policy),
 342                    "start_session action policy get");
 343         }
 344
 345         /* Ser/des tests. */
 346         ret = lttng_action_serialize(start_session_action, &payload);
 347         ok(ret == 0, "Action start_session serialized");
 348
 349         {
 350                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 351                 (void) lttng_action_create_from_payload(&view, &start_session_action_from_buffer);
 352         }
 353         ok(start_session_action_from_buffer,
 354            "start_session action created from payload is non-null");
 355
 356         ok(lttng_action_is_equal(start_session_action, start_session_action_from_buffer),
 357            "Serialized and de-serialized start_session action are equal");
 358
 359         lttng_rate_policy_destroy(default_policy);
 360         lttng_rate_policy_destroy(policy);
 361         lttng_action_destroy(start_session_action);
 362         lttng_action_destroy(start_session_action_from_buffer);
 363         lttng_payload_reset(&payload);
 364 }
 365
 366 static void test_action_stop_session()
 367 {
 368         int ret;
 369         enum lttng_action_status status;
 370         struct lttng_action *stop_session_action = nullptr,
 371                             *stop_session_action_from_buffer = nullptr;
 372         struct lttng_rate_policy *policy = nullptr, *default_policy;
 373         struct lttng_payload payload;
 374         const char *session_name = "my_session_name";
 375         const char *get_session_name;
 376
 377         lttng_payload_init(&payload);
 378
 379         /* To set. */
 380         policy = lttng_rate_policy_every_n_create(100);
 381         /* For comparison. */
 382         default_policy = lttng_rate_policy_every_n_create(1);
 383
 384         LTTNG_ASSERT(policy && default_policy);
 385
 386         stop_session_action = lttng_action_stop_session_create();
 387         ok(stop_session_action, "Create stop_session action");
 388         ok(lttng_action_get_type(stop_session_action) == LTTNG_ACTION_TYPE_STOP_SESSION,
 389            "Action has type LTTNG_ACTION_TYPE_STOP_SESSION");
 390
 391         /* Session name setter. */
 392         status = lttng_action_stop_session_set_session_name(nullptr, nullptr);
 393         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 394         status = lttng_action_stop_session_set_session_name(stop_session_action, nullptr);
 395         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 396         status = lttng_action_stop_session_set_session_name(nullptr, session_name);
 397         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 398
 399         /* Set the session name */
 400         status = lttng_action_stop_session_set_session_name(stop_session_action, session_name);
 401         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 402
 403         status = lttng_action_stop_session_get_session_name(stop_session_action, &get_session_name);
 404         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 405            "Get session name, expected `%s` got `%s`",
 406            session_name,
 407            get_session_name);
 408
 409         /* Validate the default policy for a stop_session action. */
 410         {
 411                 const struct lttng_rate_policy *cur_policy = nullptr;
 412                 status =
 413                         lttng_action_stop_session_get_rate_policy(stop_session_action, &cur_policy);
 414                 ok(status == LTTNG_ACTION_STATUS_OK &&
 415                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 416                    "Default policy is every n=1");
 417         }
 418
 419         /* Set a custom policy. */
 420         status = lttng_action_stop_session_set_rate_policy(stop_session_action, policy);
 421         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 422
 423         /* Validate the custom policy for a stop_session action. */
 424         {
 425                 const struct lttng_rate_policy *cur_policy = nullptr;
 426                 status =
 427                         lttng_action_stop_session_get_rate_policy(stop_session_action, &cur_policy);
 428                 ok(status == LTTNG_ACTION_STATUS_OK &&
 429                            lttng_rate_policy_is_equal(policy, cur_policy),
 430                    "stop_session action policy get");
 431         }
 432
 433         /* Ser/des tests. */
 434         ret = lttng_action_serialize(stop_session_action, &payload);
 435         ok(ret == 0, "Action stop_session serialized");
 436
 437         {
 438                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 439                 (void) lttng_action_create_from_payload(&view, &stop_session_action_from_buffer);
 440         }
 441         ok(stop_session_action_from_buffer, "stop_session action created from payload is non-null");
 442
 443         ok(lttng_action_is_equal(stop_session_action, stop_session_action_from_buffer),
 444            "Serialized and de-serialized stop_session action are equal");
 445
 446         lttng_rate_policy_destroy(default_policy);
 447         lttng_rate_policy_destroy(policy);
 448         lttng_action_destroy(stop_session_action);
 449         lttng_action_destroy(stop_session_action_from_buffer);
 450         lttng_payload_reset(&payload);
 451 }
 452
 453 static void test_action_snapshot_session()
 454 {
 455         int ret;
 456         enum lttng_action_status status;
 457         struct lttng_action *snapshot_session_action = nullptr,
 458                             *snapshot_session_action_from_buffer = nullptr;
 459         struct lttng_rate_policy *policy = nullptr, *default_policy;
 460         struct lttng_payload payload;
 461         const char *session_name = "my_session_name";
 462         const char *get_session_name;
 463
 464         lttng_payload_init(&payload);
 465
 466         /* To set. */
 467         policy = lttng_rate_policy_every_n_create(100);
 468         /* For comparison. */
 469         default_policy = lttng_rate_policy_every_n_create(1);
 470
 471         LTTNG_ASSERT(policy && default_policy);
 472
 473         snapshot_session_action = lttng_action_snapshot_session_create();
 474         ok(snapshot_session_action, "Create snapshot_session action");
 475         ok(lttng_action_get_type(snapshot_session_action) == LTTNG_ACTION_TYPE_SNAPSHOT_SESSION,
 476            "Action has type LTTNG_ACTION_TYPE_SNAPSHOT_SESSION");
 477
 478         /* Session name setter. */
 479         status = lttng_action_snapshot_session_set_session_name(nullptr, nullptr);
 480         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 481         status = lttng_action_snapshot_session_set_session_name(snapshot_session_action, nullptr);
 482         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 483         status = lttng_action_snapshot_session_set_session_name(nullptr, session_name);
 484         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 485
 486         /* Set the session name */
 487         status = lttng_action_snapshot_session_set_session_name(snapshot_session_action,
 488                                                                 session_name);
 489         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 490
 491         status = lttng_action_snapshot_session_get_session_name(snapshot_session_action,
 492                                                                 &get_session_name);
 493         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 494            "Get session name, expected `%s` got `%s`",
 495            session_name,
 496            get_session_name);
 497
 498         /* Validate the default policy for a snapshot_session action. */
 499         {
 500                 const struct lttng_rate_policy *cur_policy = nullptr;
 501                 status = lttng_action_snapshot_session_get_rate_policy(snapshot_session_action,
 502                                                                        &cur_policy);
 503                 ok(status == LTTNG_ACTION_STATUS_OK &&
 504                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 505                    "Default policy is every n=1");
 506         }
 507
 508         /* Set a custom policy. */
 509         status = lttng_action_snapshot_session_set_rate_policy(snapshot_session_action, policy);
 510         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 511
 512         /* Validate the custom policy for a snapshot_session action. */
 513         {
 514                 const struct lttng_rate_policy *cur_policy = nullptr;
 515                 status = lttng_action_snapshot_session_get_rate_policy(snapshot_session_action,
 516                                                                        &cur_policy);
 517                 ok(status == LTTNG_ACTION_STATUS_OK &&
 518                            lttng_rate_policy_is_equal(policy, cur_policy),
 519                    "snapshot_session action policy get");
 520         }
 521
 522         /* Ser/des tests. */
 523         ret = lttng_action_serialize(snapshot_session_action, &payload);
 524         ok(ret == 0, "Action snapshot_session serialized");
 525
 526         {
 527                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 528                 (void) lttng_action_create_from_payload(&view,
 529                                                         &snapshot_session_action_from_buffer);
 530         }
 531         ok(snapshot_session_action_from_buffer,
 532            "snapshot_session action created from payload is non-null");
 533
 534         ok(lttng_action_is_equal(snapshot_session_action, snapshot_session_action_from_buffer),
 535            "Serialized and de-serialized snapshot_session action are equal");
 536
 537         lttng_rate_policy_destroy(default_policy);
 538         lttng_rate_policy_destroy(policy);
 539         lttng_action_destroy(snapshot_session_action);
 540         lttng_action_destroy(snapshot_session_action_from_buffer);
 541         lttng_payload_reset(&payload);
 542 }
 543
 544 int main()
 545 {
 546         plan_tests(NUM_TESTS);
 547         test_action_notify();
 548         test_action_list();
 549         test_action_rotate_session();
 550         test_action_start_session();
 551         test_action_stop_session();
 552         test_action_snapshot_session();
 553         return exit_status();
 554 }