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