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                             *mut_inner_action = NULL, *stop_session_action = NULL,
 107                             *notify_action = NULL, *start_session_action = NULL;
 108         const struct lttng_action *const_inner_action;
 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_each_action_const (const_inner_action, list_action) {
 143                 enum lttng_action_type inner_action_type =
 144                         lttng_action_get_type(const_inner_action);
 145                 switch (action_idx) {
 146                 case 0:
 147                         ok(inner_action_type == LTTNG_ACTION_TYPE_START_SESSION,
 148                            "First inner action of action list is `start-session` action");
 149                         break;
 150                 case 1:
 151                         ok(inner_action_type == LTTNG_ACTION_TYPE_STOP_SESSION,
 152                            "Second inner action of action list is `stop-session` action");
 153                         break;
 154                 case 2:
 155                         ok(inner_action_type == LTTNG_ACTION_TYPE_NOTIFY,
 156                            "Third inner action of action list is `notify` action");
 157                         break;
 158                 }
 159                 action_idx++;
 160         }
 161
 162         action_idx = 0;
 163         for_each_action_mutable (mut_inner_action, list_action) {
 164                 enum lttng_action_type inner_action_type = lttng_action_get_type(mut_inner_action);
 165                 switch (action_idx) {
 166                 case 0:
 167                         ok(inner_action_type == LTTNG_ACTION_TYPE_START_SESSION,
 168                            "First inner action of action list is `start-session` action");
 169                         break;
 170                 case 1:
 171                         ok(inner_action_type == LTTNG_ACTION_TYPE_STOP_SESSION,
 172                            "Second inner action of action list is `stop-session` action");
 173                         break;
 174                 case 2:
 175                         ok(inner_action_type == LTTNG_ACTION_TYPE_NOTIFY,
 176                            "Third inner action of action list is `notify` action");
 177                         break;
 178                 }
 179                 action_idx++;
 180         }
 181
 182         lttng_action_destroy(list_action);
 183         lttng_action_destroy(list_action_from_buffer);
 184         lttng_action_destroy(start_session_action);
 185         lttng_action_destroy(stop_session_action);
 186         lttng_action_destroy(notify_action);
 187         lttng_payload_reset(&payload);
 188 }
 189
 190 static void test_action_rotate_session(void)
 191 {
 192         int ret;
 193         enum lttng_action_status status;
 194         struct lttng_action *rotate_session_action = nullptr,
 195                             *rotate_session_action_from_buffer = nullptr;
 196         struct lttng_rate_policy *policy = nullptr, *default_policy;
 197         struct lttng_payload payload;
 198         const char *session_name = "my_session_name";
 199         const char *get_session_name;
 200
 201         lttng_payload_init(&payload);
 202
 203         /* To set. */
 204         policy = lttng_rate_policy_every_n_create(100);
 205         /* For comparison. */
 206         default_policy = lttng_rate_policy_every_n_create(1);
 207
 208         LTTNG_ASSERT(policy && default_policy);
 209
 210         rotate_session_action = lttng_action_rotate_session_create();
 211         ok(rotate_session_action, "Create rotate_session action");
 212         ok(lttng_action_get_type(rotate_session_action) == LTTNG_ACTION_TYPE_ROTATE_SESSION,
 213            "Action has type LTTNG_ACTION_TYPE_ROTATE_SESSION");
 214
 215         /* Session name setter. */
 216         status = lttng_action_rotate_session_set_session_name(nullptr, nullptr);
 217         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 218         status = lttng_action_rotate_session_set_session_name(rotate_session_action, nullptr);
 219         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 220         status = lttng_action_rotate_session_set_session_name(nullptr, session_name);
 221         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 222
 223         /* Set the session name */
 224         status = lttng_action_rotate_session_set_session_name(rotate_session_action, session_name);
 225         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 226
 227         status = lttng_action_rotate_session_get_session_name(rotate_session_action,
 228                                                               &get_session_name);
 229         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 230            "Get session name, expected `%s` got `%s`",
 231            session_name,
 232            get_session_name);
 233
 234         /* Validate the default policy for a rotate_session action. */
 235         {
 236                 const struct lttng_rate_policy *cur_policy = nullptr;
 237                 status = lttng_action_rotate_session_get_rate_policy(rotate_session_action,
 238                                                                      &cur_policy);
 239                 ok(status == LTTNG_ACTION_STATUS_OK &&
 240                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 241                    "Default policy is every n=1");
 242         }
 243
 244         /* Set a custom policy. */
 245         status = lttng_action_rotate_session_set_rate_policy(rotate_session_action, policy);
 246         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 247
 248         /* Validate the custom policy for a rotate_session action. */
 249         {
 250                 const struct lttng_rate_policy *cur_policy = nullptr;
 251                 status = lttng_action_rotate_session_get_rate_policy(rotate_session_action,
 252                                                                      &cur_policy);
 253                 ok(status == LTTNG_ACTION_STATUS_OK &&
 254                            lttng_rate_policy_is_equal(policy, cur_policy),
 255                    "rotate_session action policy get");
 256         }
 257
 258         /* Ser/des tests. */
 259         ret = lttng_action_serialize(rotate_session_action, &payload);
 260         ok(ret == 0, "Action rotate_session serialized");
 261
 262         {
 263                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 264                 (void) lttng_action_create_from_payload(&view, &rotate_session_action_from_buffer);
 265         }
 266         ok(rotate_session_action_from_buffer,
 267            "rotate_session action created from payload is non-null");
 268
 269         ok(lttng_action_is_equal(rotate_session_action, rotate_session_action_from_buffer),
 270            "Serialized and de-serialized rotate_session action are equal");
 271
 272         lttng_rate_policy_destroy(default_policy);
 273         lttng_rate_policy_destroy(policy);
 274         lttng_action_destroy(rotate_session_action);
 275         lttng_action_destroy(rotate_session_action_from_buffer);
 276         lttng_payload_reset(&payload);
 277 }
 278
 279 static void test_action_start_session()
 280 {
 281         int ret;
 282         enum lttng_action_status status;
 283         struct lttng_action *start_session_action = nullptr,
 284                             *start_session_action_from_buffer = nullptr;
 285         struct lttng_rate_policy *policy = nullptr, *default_policy;
 286         struct lttng_payload payload;
 287         const char *session_name = "my_session_name";
 288         const char *get_session_name;
 289
 290         lttng_payload_init(&payload);
 291
 292         /* To set. */
 293         policy = lttng_rate_policy_every_n_create(100);
 294         /* For comparison. */
 295         default_policy = lttng_rate_policy_every_n_create(1);
 296
 297         LTTNG_ASSERT(policy && default_policy);
 298
 299         start_session_action = lttng_action_start_session_create();
 300         ok(start_session_action, "Create start_session action");
 301         ok(lttng_action_get_type(start_session_action) == LTTNG_ACTION_TYPE_START_SESSION,
 302            "Action has type LTTNG_ACTION_TYPE_START_SESSION");
 303
 304         /* Session name setter. */
 305         status = lttng_action_start_session_set_session_name(nullptr, nullptr);
 306         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 307         status = lttng_action_start_session_set_session_name(start_session_action, nullptr);
 308         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 309         status = lttng_action_start_session_set_session_name(nullptr, session_name);
 310         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 311
 312         /* Set the session name */
 313         status = lttng_action_start_session_set_session_name(start_session_action, session_name);
 314         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 315
 316         status = lttng_action_start_session_get_session_name(start_session_action,
 317                                                              &get_session_name);
 318         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 319            "Get session name, expected `%s` got `%s`",
 320            session_name,
 321            get_session_name);
 322
 323         /* Validate the default policy for a start_session action. */
 324         {
 325                 const struct lttng_rate_policy *cur_policy = nullptr;
 326                 status = lttng_action_start_session_get_rate_policy(start_session_action,
 327                                                                     &cur_policy);
 328                 ok(status == LTTNG_ACTION_STATUS_OK &&
 329                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 330                    "Default policy is every n=1");
 331         }
 332
 333         /* Set a custom policy. */
 334         status = lttng_action_start_session_set_rate_policy(start_session_action, policy);
 335         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 336
 337         /* Validate the custom policy for a start_session action. */
 338         {
 339                 const struct lttng_rate_policy *cur_policy = nullptr;
 340                 status = lttng_action_start_session_get_rate_policy(start_session_action,
 341                                                                     &cur_policy);
 342                 ok(status == LTTNG_ACTION_STATUS_OK &&
 343                            lttng_rate_policy_is_equal(policy, cur_policy),
 344                    "start_session action policy get");
 345         }
 346
 347         /* Ser/des tests. */
 348         ret = lttng_action_serialize(start_session_action, &payload);
 349         ok(ret == 0, "Action start_session serialized");
 350
 351         {
 352                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 353                 (void) lttng_action_create_from_payload(&view, &start_session_action_from_buffer);
 354         }
 355         ok(start_session_action_from_buffer,
 356            "start_session action created from payload is non-null");
 357
 358         ok(lttng_action_is_equal(start_session_action, start_session_action_from_buffer),
 359            "Serialized and de-serialized start_session action are equal");
 360
 361         lttng_rate_policy_destroy(default_policy);
 362         lttng_rate_policy_destroy(policy);
 363         lttng_action_destroy(start_session_action);
 364         lttng_action_destroy(start_session_action_from_buffer);
 365         lttng_payload_reset(&payload);
 366 }
 367
 368 static void test_action_stop_session()
 369 {
 370         int ret;
 371         enum lttng_action_status status;
 372         struct lttng_action *stop_session_action = nullptr,
 373                             *stop_session_action_from_buffer = nullptr;
 374         struct lttng_rate_policy *policy = nullptr, *default_policy;
 375         struct lttng_payload payload;
 376         const char *session_name = "my_session_name";
 377         const char *get_session_name;
 378
 379         lttng_payload_init(&payload);
 380
 381         /* To set. */
 382         policy = lttng_rate_policy_every_n_create(100);
 383         /* For comparison. */
 384         default_policy = lttng_rate_policy_every_n_create(1);
 385
 386         LTTNG_ASSERT(policy && default_policy);
 387
 388         stop_session_action = lttng_action_stop_session_create();
 389         ok(stop_session_action, "Create stop_session action");
 390         ok(lttng_action_get_type(stop_session_action) == LTTNG_ACTION_TYPE_STOP_SESSION,
 391            "Action has type LTTNG_ACTION_TYPE_STOP_SESSION");
 392
 393         /* Session name setter. */
 394         status = lttng_action_stop_session_set_session_name(nullptr, nullptr);
 395         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 396         status = lttng_action_stop_session_set_session_name(stop_session_action, nullptr);
 397         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 398         status = lttng_action_stop_session_set_session_name(nullptr, session_name);
 399         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 400
 401         /* Set the session name */
 402         status = lttng_action_stop_session_set_session_name(stop_session_action, session_name);
 403         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 404
 405         status = lttng_action_stop_session_get_session_name(stop_session_action, &get_session_name);
 406         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 407            "Get session name, expected `%s` got `%s`",
 408            session_name,
 409            get_session_name);
 410
 411         /* Validate the default policy for a stop_session action. */
 412         {
 413                 const struct lttng_rate_policy *cur_policy = nullptr;
 414                 status =
 415                         lttng_action_stop_session_get_rate_policy(stop_session_action, &cur_policy);
 416                 ok(status == LTTNG_ACTION_STATUS_OK &&
 417                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 418                    "Default policy is every n=1");
 419         }
 420
 421         /* Set a custom policy. */
 422         status = lttng_action_stop_session_set_rate_policy(stop_session_action, policy);
 423         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 424
 425         /* Validate the custom policy for a stop_session action. */
 426         {
 427                 const struct lttng_rate_policy *cur_policy = nullptr;
 428                 status =
 429                         lttng_action_stop_session_get_rate_policy(stop_session_action, &cur_policy);
 430                 ok(status == LTTNG_ACTION_STATUS_OK &&
 431                            lttng_rate_policy_is_equal(policy, cur_policy),
 432                    "stop_session action policy get");
 433         }
 434
 435         /* Ser/des tests. */
 436         ret = lttng_action_serialize(stop_session_action, &payload);
 437         ok(ret == 0, "Action stop_session serialized");
 438
 439         {
 440                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 441                 (void) lttng_action_create_from_payload(&view, &stop_session_action_from_buffer);
 442         }
 443         ok(stop_session_action_from_buffer, "stop_session action created from payload is non-null");
 444
 445         ok(lttng_action_is_equal(stop_session_action, stop_session_action_from_buffer),
 446            "Serialized and de-serialized stop_session action are equal");
 447
 448         lttng_rate_policy_destroy(default_policy);
 449         lttng_rate_policy_destroy(policy);
 450         lttng_action_destroy(stop_session_action);
 451         lttng_action_destroy(stop_session_action_from_buffer);
 452         lttng_payload_reset(&payload);
 453 }
 454
 455 static void test_action_snapshot_session()
 456 {
 457         int ret;
 458         enum lttng_action_status status;
 459         struct lttng_action *snapshot_session_action = nullptr,
 460                             *snapshot_session_action_from_buffer = nullptr;
 461         struct lttng_rate_policy *policy = nullptr, *default_policy;
 462         struct lttng_payload payload;
 463         const char *session_name = "my_session_name";
 464         const char *get_session_name;
 465
 466         lttng_payload_init(&payload);
 467
 468         /* To set. */
 469         policy = lttng_rate_policy_every_n_create(100);
 470         /* For comparison. */
 471         default_policy = lttng_rate_policy_every_n_create(1);
 472
 473         LTTNG_ASSERT(policy && default_policy);
 474
 475         snapshot_session_action = lttng_action_snapshot_session_create();
 476         ok(snapshot_session_action, "Create snapshot_session action");
 477         ok(lttng_action_get_type(snapshot_session_action) == LTTNG_ACTION_TYPE_SNAPSHOT_SESSION,
 478            "Action has type LTTNG_ACTION_TYPE_SNAPSHOT_SESSION");
 479
 480         /* Session name setter. */
 481         status = lttng_action_snapshot_session_set_session_name(nullptr, nullptr);
 482         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 483         status = lttng_action_snapshot_session_set_session_name(snapshot_session_action, nullptr);
 484         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 485         status = lttng_action_snapshot_session_set_session_name(nullptr, session_name);
 486         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 487
 488         /* Set the session name */
 489         status = lttng_action_snapshot_session_set_session_name(snapshot_session_action,
 490                                                                 session_name);
 491         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 492
 493         status = lttng_action_snapshot_session_get_session_name(snapshot_session_action,
 494                                                                 &get_session_name);
 495         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 496            "Get session name, expected `%s` got `%s`",
 497            session_name,
 498            get_session_name);
 499
 500         /* Validate the default policy for a snapshot_session action. */
 501         {
 502                 const struct lttng_rate_policy *cur_policy = nullptr;
 503                 status = lttng_action_snapshot_session_get_rate_policy(snapshot_session_action,
 504                                                                        &cur_policy);
 505                 ok(status == LTTNG_ACTION_STATUS_OK &&
 506                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 507                    "Default policy is every n=1");
 508         }
 509
 510         /* Set a custom policy. */
 511         status = lttng_action_snapshot_session_set_rate_policy(snapshot_session_action, policy);
 512         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 513
 514         /* Validate the custom policy for a snapshot_session action. */
 515         {
 516                 const struct lttng_rate_policy *cur_policy = nullptr;
 517                 status = lttng_action_snapshot_session_get_rate_policy(snapshot_session_action,
 518                                                                        &cur_policy);
 519                 ok(status == LTTNG_ACTION_STATUS_OK &&
 520                            lttng_rate_policy_is_equal(policy, cur_policy),
 521                    "snapshot_session action policy get");
 522         }
 523
 524         /* Ser/des tests. */
 525         ret = lttng_action_serialize(snapshot_session_action, &payload);
 526         ok(ret == 0, "Action snapshot_session serialized");
 527
 528         {
 529                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 530                 (void) lttng_action_create_from_payload(&view,
 531                                                         &snapshot_session_action_from_buffer);
 532         }
 533         ok(snapshot_session_action_from_buffer,
 534            "snapshot_session action created from payload is non-null");
 535
 536         ok(lttng_action_is_equal(snapshot_session_action, snapshot_session_action_from_buffer),
 537            "Serialized and de-serialized snapshot_session action are equal");
 538
 539         lttng_rate_policy_destroy(default_policy);
 540         lttng_rate_policy_destroy(policy);
 541         lttng_action_destroy(snapshot_session_action);
 542         lttng_action_destroy(snapshot_session_action_from_buffer);
 543         lttng_payload_reset(&payload);
 544 }
 545
 546 int main()
 547 {
 548         plan_tests(NUM_TESTS);
 549         test_action_notify();
 550         test_action_list();
 551         test_action_rotate_session();
 552         test_action_start_session();
 553         test_action_stop_session();
 554         test_action_snapshot_session();
 555         return exit_status();
 556 }