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