tests/unit/test_log_level_rule.cpp

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