tests/unit/test_log_level_rule.c

   1 /*
   2  * Unit tests for the log level rule API.
   3  *
   4  * Copyright (C) 2020 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/log-level-rule-internal.h>
  21 #include <lttng/log-level-rule.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 29
  29
  30 static void test_log_level_rule_error(void)
  31 {
  32         int level = 9000;
  33         struct lttng_log_level_rule *exactly =
  34                         lttng_log_level_rule_exactly_create(level);
  35         struct lttng_log_level_rule *at_least_as_severe =
  36                         lttng_log_level_rule_at_least_as_severe_as_create(
  37                                         level);
  38
  39         ok(lttng_log_level_rule_get_type(NULL) == LTTNG_LOG_LEVEL_RULE_TYPE_UNKNOWN, "Get type on invalid pointer");
  40
  41         ok(lttng_log_level_rule_exactly_get_level(NULL, NULL) == LTTNG_LOG_LEVEL_RULE_STATUS_INVALID, "lttng_log_level_rule_exactly_get_level (NULL, NULL) returns invalid");
  42         ok(lttng_log_level_rule_exactly_get_level(exactly, NULL) == LTTNG_LOG_LEVEL_RULE_STATUS_INVALID, "lttng_log_level_rule_exactly_get_level (valid, NULL) returns invalid");
  43         ok(lttng_log_level_rule_exactly_get_level(NULL, &level) == LTTNG_LOG_LEVEL_RULE_STATUS_INVALID, "lttng_log_level_rule_exactly_get_level (NULL, valid) returns invalid");
  44
  45         ok(lttng_log_level_rule_at_least_as_severe_as_get_level(NULL, NULL) == LTTNG_LOG_LEVEL_RULE_STATUS_INVALID, "lttng_log_level_rule_at_least_as_severe_as_get_level (NULL, NULL) returns invalid");
  46         ok(lttng_log_level_rule_at_least_as_severe_as_get_level(exactly, NULL) == LTTNG_LOG_LEVEL_RULE_STATUS_INVALID, "lttng_log_level_rule_at_least_as_severe_as_get_level (valid, NULL) returns invalid");
  47         ok(lttng_log_level_rule_at_least_as_severe_as_get_level(NULL, &level) == LTTNG_LOG_LEVEL_RULE_STATUS_INVALID, "lttng_log_level_rule_at_least_as_severe_as_get_level (NULL, valid) returns invalid");
  48
  49         lttng_log_level_rule_destroy(exactly);
  50         lttng_log_level_rule_destroy(at_least_as_severe);
  51 }
  52
  53 static
  54 void test_log_level_rule_serialize_deserialize(const struct lttng_log_level_rule *rule)
  55 {
  56         struct lttng_log_level_rule *log_level_rule_from_buffer = NULL;
  57         struct lttng_payload payload;
  58
  59         lttng_payload_init(&payload);
  60
  61         ok(lttng_log_level_rule_serialize(rule, &payload) == 0, "Serializing.");
  62
  63         {
  64                 struct lttng_payload_view view =
  65                                 lttng_payload_view_from_payload(
  66                                                 &payload, 0, -1);
  67
  68                 ok(lttng_log_level_rule_create_from_payload(
  69                                 &view, &log_level_rule_from_buffer) > 0,
  70                                 "Deserializing.");
  71         }
  72
  73         ok(lttng_log_level_rule_is_equal(rule, log_level_rule_from_buffer), "Serialized and from buffer are equal");
  74
  75         lttng_log_level_rule_destroy(log_level_rule_from_buffer);
  76         lttng_payload_reset(&payload);
  77 }
  78
  79 static
  80 void test_log_level_rule_is_equal_exactly(void)
  81 {
  82         int level = 9000, no_eq_level = 420;
  83         struct lttng_log_level_rule *a, *b, *different_level, *different_type;
  84
  85         /* Identical log level rules. */
  86         a = lttng_log_level_rule_exactly_create(level);
  87         b = lttng_log_level_rule_exactly_create(level);
  88
  89         /* Different level, same type. */
  90         different_level = lttng_log_level_rule_exactly_create(no_eq_level);
  91
  92         /* Different type. */
  93         different_type = lttng_log_level_rule_at_least_as_severe_as_create(level);
  94
  95         assert(a && b && different_level && different_type);
  96
  97         ok(lttng_log_level_rule_is_equal(a, a), "Same object is equal");
  98         ok(lttng_log_level_rule_is_equal(a, b), "Object a and b are equal");
  99         ok(!lttng_log_level_rule_is_equal(a, different_level), " Object of different levels are not equal");
 100         ok(!lttng_log_level_rule_is_equal(a, different_type), " Object of different types are not equal");
 101
 102         lttng_log_level_rule_destroy(a);
 103         lttng_log_level_rule_destroy(b);
 104         lttng_log_level_rule_destroy(different_level);
 105         lttng_log_level_rule_destroy(different_type);
 106 }
 107
 108 static
 109 void test_log_level_rule_is_equal_at_least_as_severe_as(void)
 110 {
 111         int level = 9000, no_eq_level = 420;
 112         struct lttng_log_level_rule *a, *b, *different_level, *different_type;
 113
 114         /* Identical log level rules. */
 115         a = lttng_log_level_rule_at_least_as_severe_as_create(level);
 116         b = lttng_log_level_rule_at_least_as_severe_as_create(level);
 117
 118         /* Different level, same type. */
 119         different_level = lttng_log_level_rule_at_least_as_severe_as_create(no_eq_level);
 120
 121         /* Different type. */
 122         different_type = lttng_log_level_rule_exactly_create(level);
 123
 124         assert(a && b && different_level && different_type);
 125
 126         ok(lttng_log_level_rule_is_equal(a, a), "Same object is equal");
 127         ok(lttng_log_level_rule_is_equal(a, b), "Object a and b are equal");
 128         ok(!lttng_log_level_rule_is_equal(a, different_level), " Object of different levels are not equal");
 129         ok(!lttng_log_level_rule_is_equal(a, different_type), " Object of different types are not equal");
 130
 131         lttng_log_level_rule_destroy(a);
 132         lttng_log_level_rule_destroy(b);
 133         lttng_log_level_rule_destroy(different_level);
 134         lttng_log_level_rule_destroy(different_type);
 135 }
 136
 137 static void test_log_level_rule_exactly(void)
 138 {
 139         int level = 9000;
 140         int _level;
 141         struct lttng_log_level_rule *exactly = NULL;
 142         enum lttng_log_level_rule_status status;
 143
 144         exactly = lttng_log_level_rule_exactly_create(level);
 145
 146         ok(exactly, "Log level exactly allocated");
 147         ok(lttng_log_level_rule_get_type(exactly) ==
 148                                         LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY,
 149                         "Log level rule exactly type");
 150
 151         status = lttng_log_level_rule_exactly_get_level(exactly, &_level);
 152         ok(status == LTTNG_LOG_LEVEL_RULE_STATUS_OK, "Get the level");
 153         ok(_level == level, "Level property is valid");
 154
 155         test_log_level_rule_is_equal_exactly();
 156         test_log_level_rule_serialize_deserialize(exactly);
 157         lttng_log_level_rule_destroy(exactly);
 158 }
 159
 160 static void test_log_level_rule_at_least_as_severe_as(void)
 161 {
 162         int level = 9000;
 163         int _level;
 164         struct lttng_log_level_rule *at_least_as_severe_as = NULL;
 165         enum lttng_log_level_rule_status status;
 166
 167         at_least_as_severe_as = lttng_log_level_rule_at_least_as_severe_as_create(level);
 168
 169         ok(at_least_as_severe_as, "Log level at_least_as_severe_as allocated");
 170         ok(lttng_log_level_rule_get_type(at_least_as_severe_as) ==
 171                                         LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS,
 172                         "Log level rule at_least_as_severe_as type");
 173
 174         status = lttng_log_level_rule_at_least_as_severe_as_get_level(at_least_as_severe_as, &_level);
 175         ok(status == LTTNG_LOG_LEVEL_RULE_STATUS_OK, "Get the level");
 176         ok(_level == level, "Level property is valid");
 177
 178         test_log_level_rule_is_equal_at_least_as_severe_as();
 179         test_log_level_rule_serialize_deserialize(at_least_as_severe_as);
 180         lttng_log_level_rule_destroy(at_least_as_severe_as);
 181 }
 182
 183 int main(int argc, const char *argv[])
 184 {
 185         plan_tests(NUM_TESTS);
 186         test_log_level_rule_exactly();
 187         test_log_level_rule_at_least_as_severe_as();
 188         test_log_level_rule_error();
 189         return exit_status();
 190 }