tests/unit/test_rate_policy.c

   1 /*
   2  * Unit tests for the rate policy object API.
   3  *
   4  * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
   5  *
   6  * SPDX-License-Identifier: LGPL-2.1-only
   7  *
   8  */
   9
  10 #include <assert.h>
  11 #include <inttypes.h>
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <unistd.h>
  15
  16 #include <tap/tap.h>
  17
  18 #include <common/payload-view.h>
  19 #include <common/payload.h>
  20 #include <lttng/action/rate-policy-internal.h>
  21 #include <lttng/action/rate-policy.h>
  22
  23 /* For error.h. */
  24 int lttng_opt_quiet = 1;
  25 int lttng_opt_verbose;
  26 int lttng_opt_mi;
  27
  28 #define NUM_TESTS 42
  29
  30 static void test_rate_policy_every_n(void)
  31 {
  32         enum lttng_rate_policy_status status;
  33         struct lttng_rate_policy *policy_a = NULL; /* Interval of 100. */
  34         struct lttng_rate_policy *policy_b = NULL; /* Interval of 100 */
  35         struct lttng_rate_policy *policy_c = NULL; /* Interval of 1 */
  36         struct lttng_rate_policy *policy_from_buffer = NULL;
  37         uint64_t interval_a_b = 100;
  38         uint64_t interval_c = 1;
  39         uint64_t interval_query = 0;
  40         struct lttng_payload payload;
  41
  42         lttng_payload_init(&payload);
  43
  44         policy_a = lttng_rate_policy_every_n_create(interval_a_b);
  45         policy_b = lttng_rate_policy_every_n_create(interval_a_b);
  46         policy_c = lttng_rate_policy_every_n_create(interval_c);
  47         ok(policy_a != NULL,
  48                         "Rate policy every n A created: interval: %" PRIu64,
  49                         interval_a_b);
  50         ok(policy_b != NULL,
  51                         "Rate policy every n B created: interval: %" PRIu64,
  52                         interval_a_b);
  53         ok(policy_c != NULL,
  54                         "Rate policy every n C created: interval: %" PRIu64,
  55                         interval_c);
  56
  57         ok(LTTNG_RATE_POLICY_TYPE_EVERY_N ==
  58                                         lttng_rate_policy_get_type(policy_a),
  59                         "Type is LTTNG_RATE_POLICY_TYPE_EVERY_N");
  60
  61         /* Getter tests */
  62         status = lttng_rate_policy_every_n_get_interval(NULL, NULL);
  63         ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
  64                         "Get interval returns INVALID");
  65
  66         status = lttng_rate_policy_every_n_get_interval(NULL, &interval_query);
  67         ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
  68                         "Get interval returns INVALID");
  69
  70         status = lttng_rate_policy_every_n_get_interval(policy_a, NULL);
  71         ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
  72                         "Get interval returns INVALID");
  73
  74         status = lttng_rate_policy_every_n_get_interval(
  75                         policy_a, &interval_query);
  76         ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
  77                                         interval_query == interval_a_b,
  78                         " Getting interval A");
  79
  80         status = lttng_rate_policy_every_n_get_interval(
  81                         policy_b, &interval_query);
  82         ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
  83                                         interval_query == interval_a_b,
  84                         " Getting interval B");
  85
  86         status = lttng_rate_policy_every_n_get_interval(
  87                         policy_c, &interval_query);
  88         ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
  89                                         interval_query == interval_c,
  90                         " Getting interval C");
  91
  92         /* is_equal tests */
  93         /* TODO: this is the behaviour introduced by the
  94          * lttng_condition_is_equal back in 2017 do we want to fix this and
  95          * return true if both are NULL?
  96          */
  97         ok(false == lttng_rate_policy_is_equal(NULL, NULL),
  98                         "is equal (NULL,NULL)");
  99         ok(false == lttng_rate_policy_is_equal(policy_a, NULL),
 100                         "is equal (object, NULL)");
 101         ok(false == lttng_rate_policy_is_equal(NULL, policy_a),
 102                         " is equal (NULL, object)");
 103         ok(true == lttng_rate_policy_is_equal(policy_a, policy_a),
 104                         "is equal (object A, object A)");
 105
 106         ok(true == lttng_rate_policy_is_equal(policy_a, policy_b),
 107                         "is equal (object A, object B");
 108         ok(true == lttng_rate_policy_is_equal(policy_b, policy_a),
 109                         "is equal (object B, object A");
 110
 111         ok(false == lttng_rate_policy_is_equal(policy_a, policy_c),
 112                         "is equal (object A, object C)");
 113         ok(false == lttng_rate_policy_is_equal(policy_c, policy_a),
 114                         "is equal (object C, object A)");
 115
 116         /* Serialization and create_from buffer. */
 117         ok(lttng_rate_policy_serialize(policy_a, &payload) == 0, "Serializing");
 118         {
 119                 struct lttng_payload_view view =
 120                                 lttng_payload_view_from_payload(
 121                                                 &payload, 0, -1);
 122
 123                 ok(lttng_rate_policy_create_from_payload(
 124                                    &view, &policy_from_buffer) > 0 &&
 125                                                 policy_from_buffer != NULL,
 126                                 "Deserializing");
 127         }
 128
 129         ok(lttng_rate_policy_is_equal(policy_a, policy_from_buffer),
 130                         "serialized and from buffer are equal");
 131
 132         lttng_rate_policy_destroy(policy_a);
 133         lttng_rate_policy_destroy(policy_b);
 134         lttng_rate_policy_destroy(policy_c);
 135         lttng_payload_reset(&payload);
 136 }
 137
 138 static void test_rate_policy_once_after_n(void)
 139 {
 140         enum lttng_rate_policy_status status;
 141         struct lttng_rate_policy *policy_a = NULL; /* Threshold of 100. */
 142         struct lttng_rate_policy *policy_b = NULL; /* threshold of 100 */
 143         struct lttng_rate_policy *policy_c = NULL; /* threshold of 1 */
 144         struct lttng_rate_policy *policy_from_buffer = NULL;
 145         uint64_t threshold_a_b = 100;
 146         uint64_t threshold_c = 1;
 147         uint64_t threshold_query = 0;
 148         struct lttng_payload payload;
 149
 150         lttng_payload_init(&payload);
 151
 152         policy_a = lttng_rate_policy_once_after_n_create(threshold_a_b);
 153         policy_b = lttng_rate_policy_once_after_n_create(threshold_a_b);
 154         policy_c = lttng_rate_policy_once_after_n_create(threshold_c);
 155         ok(policy_a != NULL,
 156                         "Rate policy every n A created: threshold: %" PRIu64,
 157                         threshold_a_b);
 158         ok(policy_b != NULL,
 159                         "Rate policy every n B created: threshold: %" PRIu64,
 160                         threshold_a_b);
 161         ok(policy_c != NULL,
 162                         "Rate policy every n C created: threshold: %" PRIu64,
 163                         threshold_c);
 164
 165         ok(LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N ==
 166                                         lttng_rate_policy_get_type(policy_a),
 167                         "Type is LTTNG_RATE_POLICY_TYPE_once_after_n");
 168
 169         /* Getter tests */
 170         status = lttng_rate_policy_once_after_n_get_threshold(NULL, NULL);
 171         ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
 172                         "Get threshold returns INVALID");
 173
 174         status = lttng_rate_policy_once_after_n_get_threshold(
 175                         NULL, &threshold_query);
 176         ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
 177                         "Get threshold returns INVALID");
 178
 179         status = lttng_rate_policy_once_after_n_get_threshold(policy_a, NULL);
 180         ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
 181                         "Get threshold returns INVALID");
 182
 183         status = lttng_rate_policy_once_after_n_get_threshold(
 184                         policy_a, &threshold_query);
 185         ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
 186                                         threshold_query == threshold_a_b,
 187                         " Getting threshold A");
 188
 189         status = lttng_rate_policy_once_after_n_get_threshold(
 190                         policy_b, &threshold_query);
 191         ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
 192                                         threshold_query == threshold_a_b,
 193                         " Getting threshold B");
 194
 195         status = lttng_rate_policy_once_after_n_get_threshold(
 196                         policy_c, &threshold_query);
 197         ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
 198                                         threshold_query == threshold_c,
 199                         " Getting threshold C");
 200
 201         /* is_equal tests */
 202         /* TODO: this is the behaviour introduced by the
 203          * lttng_condition_is_equal back in 2017 do we want to fix this and
 204          * return true if both are NULL?
 205          */
 206         ok(false == lttng_rate_policy_is_equal(NULL, NULL),
 207                         "is equal (NULL,NULL)");
 208         ok(false == lttng_rate_policy_is_equal(policy_a, NULL),
 209                         "is equal (object, NULL)");
 210         ok(false == lttng_rate_policy_is_equal(NULL, policy_a),
 211                         " is equal (NULL, object)");
 212         ok(true == lttng_rate_policy_is_equal(policy_a, policy_a),
 213                         "is equal (object A, object A)");
 214
 215         ok(true == lttng_rate_policy_is_equal(policy_a, policy_b),
 216                         "is equal (object A, object B");
 217         ok(true == lttng_rate_policy_is_equal(policy_b, policy_a),
 218                         "is equal (object B, object A");
 219
 220         ok(false == lttng_rate_policy_is_equal(policy_a, policy_c),
 221                         "is equal (object A, object C)");
 222         ok(false == lttng_rate_policy_is_equal(policy_c, policy_a),
 223                         "is equal (object C, object A)");
 224
 225         /* Serialization and create_from buffer. */
 226         ok(lttng_rate_policy_serialize(policy_a, &payload) == 0, "Serializing");
 227         {
 228                 struct lttng_payload_view view =
 229                                 lttng_payload_view_from_payload(
 230                                                 &payload, 0, -1);
 231
 232                 ok(lttng_rate_policy_create_from_payload(
 233                                    &view, &policy_from_buffer) > 0 &&
 234                                                 policy_from_buffer != NULL,
 235                                 "Deserializing");
 236         }
 237
 238         ok(lttng_rate_policy_is_equal(policy_a, policy_from_buffer),
 239                         "serialized and from buffer are equal");
 240
 241         lttng_rate_policy_destroy(policy_a);
 242         lttng_rate_policy_destroy(policy_b);
 243         lttng_rate_policy_destroy(policy_c);
 244         lttng_payload_reset(&payload);
 245 }
 246
 247 int main(int argc, const char *argv[])
 248 {
 249         plan_tests(NUM_TESTS);
 250         test_rate_policy_every_n();
 251         test_rate_policy_once_after_n();
 252         return exit_status();
 253 }